diff --git a/Benchmarks/IxVM.lean b/Benchmarks/IxVM.lean
index ffb463369..6586de42d 100644
--- a/Benchmarks/IxVM.lean
+++ b/Benchmarks/IxVM.lean
@@ -1,5 +1,6 @@
 import Ix.Meta
 import Ix.IxVM
+import Ix.IxVM.Toplevel
 import Ix.Aiur.Protocol
 import Ix.Aiur.Compiler
 import Ix.Benchmark.Bench
diff --git a/Benchmarks/RecursionDebug.lean b/Benchmarks/RecursionDebug.lean
index a9d154e39..f0e7bb062 100644
--- a/Benchmarks/RecursionDebug.lean
+++ b/Benchmarks/RecursionDebug.lean
@@ -1,4 +1,5 @@
 import Ix.IxVM
+import Ix.IxVM.Toplevel
 import Ix.IxVM.ClaimHarness
 import Ix.Aiur.Protocol
 import Ix.Aiur.Compiler
@@ -65,7 +66,9 @@ def secs (t0 t1 : Nat) : Float := (Float.ofNat (t1 - t0)) / 1e9
 /-- Prove `constName`'s typecheck and return `(proofBytes, vkBytes, claimBytes)`. -/
 def proveConst (ixePath constName : String) (skipDeps : Bool)
     (fri : Aiur.FriParameters) : IO (Option (ByteArray × ByteArray × ByteArray)) := do
-  let .ok toplevel := IxVM.ixVM
+  -- `--skip-deps` uses the subject-only `verify_const`, which the
+  -- production toplevel no longer carries.
+  let .ok toplevel := (if skipDeps then IxVM.ixVMFull else IxVM.ixVM)
     | IO.eprintln "IxVM toplevel merge failed"; return none
   let .ok compiled := toplevel.compile
     | IO.eprintln "IxVM compile failed"; return none
diff --git a/Benchmarks/Typecheck.lean b/Benchmarks/Typecheck.lean
index de3c83e95..983772aae 100644
--- a/Benchmarks/Typecheck.lean
+++ b/Benchmarks/Typecheck.lean
@@ -1,5 +1,6 @@
 import Cli
 import Ix.IxVM
+import Ix.IxVM.Toplevel
 import Ix.Aiur.Protocol
 import Ix.Aiur.Compiler
 import Ix.Aiur.Statistics
@@ -70,9 +71,11 @@ For each constant the harness STARK-checks `Ix.Claim.check addr none` (the full
 transitive typecheck) in two phases:
 
 1. **Execute** (every constant): run the bytecode out-of-circuit. Cheap and
-   deterministic, so we always record `constants` (closure size), `fft-cost`
-   (Σ width·height·log2(height) over circuits — the proving-cost proxy), and
-   `execute-time`.
+   deterministic, so we always record `constants` (the number of constants the
+   kernel actually typechecked: `check_const`'s unique query count — NOT the
+   shipped byte scope, which also carries primitive bytes the kernel may
+   never touch), `fft-cost` (Σ width·height·log2(height) over circuits — the
+   proving-cost proxy), and `execute-time`.
 2. **Prove** (cheap→expensive by measured fft-cost): the end-to-end STARK prove,
    recording `prove-time`, the serialized `proof-size` (bytes), and
    `verify-time` (verifying the fresh proof) — prover changes can trade speed
@@ -314,13 +317,21 @@ def runTypecheckCmd (p : Cli.Parsed) : IO UInt32 := do
   | _, _ => pure ()
 
   -- Compile the IxVM kernel once; build the prover system once.
-  let .ok toplevel := IxVM.ixVM
+  -- `--skip-deps` proves the subject-only `verify_const`, a debug
+  -- entrypoint absent from the production toplevel, so it needs the full
+  -- one — and is thereby measuring a DIFFERENT verifying key than a
+  -- claim run, which is the honest reading of those numbers.
+  let .ok toplevel := (if skipDeps then IxVM.ixVMFull else IxVM.ixVM)
     | throw (IO.userError "Merging IxVM kernel failed")
   let .ok compiled := toplevel.compile
     | throw (IO.userError "Compilation of IxVM kernel failed")
   let entrypoint := if skipDeps then `verify_const else `verify_claim
   let some funIdx := compiled.getFuncIdx entrypoint
     | throw (IO.userError s!"{entrypoint} entrypoint missing")
+  -- `check_const`'s unique query count is the `constants` metric below;
+  -- resolve it up front so a kernel rename fails the run, not the metric.
+  let some checkConstIdx := compiled.getFuncIdx `check_const
+    | throw (IO.userError "check_const missing from compiled kernel")
   -- Recursive mode runs the WHOLE system — the inner prove included — under
   -- the recursion-tuned parameters, so the verifier's query loop stays
   -- tractable (cost scales with numQueries).
@@ -398,7 +409,15 @@ def runTypecheckCmd (p : Cli.Parsed) : IO UInt32 := do
              failed := true }, addr)
       | .ok (_, _, queryCounts) =>
         let stats := Aiur.computeStats compiled queryCounts
-        let constants := (IxVM.ClaimHarness.closureFrom ixonEnv addr).size
+        -- Constants CHECKED, not shipped: `check_const` is memoized per
+        -- (ci, addr), so its unique query count is exactly the number of
+        -- constants the kernel typechecked. The shipped byte scope
+        -- (`closureFrom`) is a superset (primitive bytes seeded for
+        -- reduction), so counting it would inflate throughput.
+        let some qc := queryCounts[checkConstIdx]?
+          | throw (IO.userError s!"queryCounts has no entry for check_const \
+              (idx {checkConstIdx}, {queryCounts.size} entries)")
+        let constants := qc.uniqueRows
         -- Throughput via the shared benchmark framework; duration/RAM per
         -- phase stream from texray's `aiur/execute_ixvm` span line.
         let thrpt := (Throughput.Elements constants.toUInt64 "consts").formatRate
@@ -409,7 +428,14 @@ def runTypecheckCmd (p : Cli.Parsed) : IO UInt32 := do
           ({ name := label, constants, fftCost := stats.totalFftCost,
              executeSec := execSec, executePeakRss := some execPeak }, addr)
     catch e =>
+      -- Record the failure rather than dropping the constant. A silent
+      -- drop left `execed.any (·.failed)` clear, so a thrown constant —
+      -- including the `check_const`-missing throw above — yielded an
+      -- exit-0 run with one fewer row and no other trace.
       IO.eprintln s!"  execute {label} threw: {e}"
+      execed := execed.push
+        ({ name := label, constants := 0, fftCost := 0, executeSec := 0,
+           failed := true }, addr)
 
   -- Persist rows when `--json` was given, MERGING into the file (the shared
   -- results-row contract): rows land after each result, so a kill leaves the
@@ -477,10 +503,18 @@ def runTypecheckCmd (p : Cli.Parsed) : IO UInt32 := do
         let proofBytes := Aiur.Proof.toBytes proof
         let (verifyRes, verifySec) ← timed fun _ =>
           aiurSystem.verify claim proof
+        -- A proof that does not verify is a correctness alarm, not a slow
+        -- row: mark the entry FAILED so `status` says so and the run
+        -- exits non-zero. Leaving `failed` clear emitted `"status":"ok"`
+        -- with prove-time and proof-size present, the only signal being
+        -- an absent `verify-time` key — invisible to anything keying on
+        -- status.
+        let mut r := r
         let verifySec? ← match verifyRes with
           | .ok () => pure (some verifySec)
           | .error e =>
             IO.eprintln s!"  verify {r.name} FAILED: {e}"
+            r := { r with failed := true }
             pure none
         IO.println s!"  {r.name}: prove={proveSec}s verify={verifySec}s \
           proof={proofBytes.size} bytes (cumulative {spent}s)"
diff --git a/Ix/Aiur/Compiler/Check.lean b/Ix/Aiur/Compiler/Check.lean
index a7f7dcabf..13fb15712 100644
--- a/Ix/Aiur/Compiler/Check.lean
+++ b/Ix/Aiur/Compiler/Check.lean
@@ -847,11 +847,11 @@ def inferTerm (t : Term) : CheckM Typed.Term := match t with
       let ret' ← inferTerm ret
       pure (Typed.Term.ioWrite ret'.typ ret'.escapes channel' data' ret')
     | typ' => throw $ .notAnArray typ'
-  | .assertEq a b ret => do
+  | .assertEq a b msg ret => do
     let a' ← inferNoEscape a
     let b' ← checkNoEscape b a'.typ
     let ret' ← inferTerm ret
-    pure (Typed.Term.assertEq ret'.typ ret'.escapes a' b' ret')
+    pure (Typed.Term.assertEq ret'.typ ret'.escapes a' b' msg ret')
   | .debug label term ret => do
     let term' ← match term with
       | none => pure none
@@ -958,8 +958,9 @@ def zonkTypedTerm (t : Typed.Term) : CheckM Typed.Term := match t with
   | .store τ e a => do pure (.store (← zonkTyp τ) e (← zonkTypedTerm a))
   | .load τ e a => do pure (.load (← zonkTyp τ) e (← zonkTypedTerm a))
   | .ptrVal τ e a => do pure (.ptrVal (← zonkTyp τ) e (← zonkTypedTerm a))
-  | .assertEq τ e a b r => do
-      pure (.assertEq (← zonkTyp τ) e (← zonkTypedTerm a) (← zonkTypedTerm b) (← zonkTypedTerm r))
+  | .assertEq τ e a b msg r => do
+      pure (.assertEq (← zonkTyp τ) e (← zonkTypedTerm a) (← zonkTypedTerm b)
+        msg (← zonkTypedTerm r))
   | .ioGetInfo τ e c k => do
       pure (.ioGetInfo (← zonkTyp τ) e (← zonkTypedTerm c) (← zonkTypedTerm k))
   | .ioSetInfo τ e c k i l r => do
diff --git a/Ix/Aiur/Compiler/Concretize.lean b/Ix/Aiur/Compiler/Concretize.lean
index 77b735d68..e4af5bd36 100644
--- a/Ix/Aiur/Compiler/Concretize.lean
+++ b/Ix/Aiur/Compiler/Concretize.lean
@@ -306,9 +306,10 @@ def termToConcrete
   | .store τ e a => do pure (.store (← typToConcrete mono τ) e (← termToConcrete mono a))
   | .load τ e a => do pure (.load (← typToConcrete mono τ) e (← termToConcrete mono a))
   | .ptrVal τ e a => do pure (.ptrVal (← typToConcrete mono τ) e (← termToConcrete mono a))
-  | .assertEq τ e a b r => do
+  | .assertEq τ e a b msg r => do
       pure (.assertEq (← typToConcrete mono τ) e
-                      (← termToConcrete mono a) (← termToConcrete mono b) (← termToConcrete mono r))
+                      (← termToConcrete mono a) (← termToConcrete mono b)
+                      msg (← termToConcrete mono r))
   | .ioGetInfo τ e c k => do
       pure (.ioGetInfo (← typToConcrete mono τ) e
                        (← termToConcrete mono c) (← termToConcrete mono k))
@@ -530,10 +531,10 @@ def rewriteTypedTerm (decls : Typed.Decls)
   | .store τ e a => .store (rewriteTyp subst mono τ) e (rewriteTypedTerm decls subst mono a)
   | .load τ e a => .load (rewriteTyp subst mono τ) e (rewriteTypedTerm decls subst mono a)
   | .ptrVal τ e a => .ptrVal (rewriteTyp subst mono τ) e (rewriteTypedTerm decls subst mono a)
-  | .assertEq τ e a b r =>
+  | .assertEq τ e a b msg r =>
     .assertEq (rewriteTyp subst mono τ) e
               (rewriteTypedTerm decls subst mono a) (rewriteTypedTerm decls subst mono b)
-              (rewriteTypedTerm decls subst mono r)
+              msg (rewriteTypedTerm decls subst mono r)
   | .ioGetInfo τ e c k =>
     .ioGetInfo (rewriteTyp subst mono τ) e
       (rewriteTypedTerm decls subst mono c) (rewriteTypedTerm decls subst mono k)
@@ -669,7 +670,7 @@ def collectInTypedTerm (seen : Std.HashSet (Global × Array Typ)) :
   | .proj τ _ a _ | .get τ _ a _ | .slice τ _ a _ _ =>
     collectInTypedTerm (collectInTyp seen τ) a
   | .set τ _ a _ v => collectInTypedTerm (collectInTypedTerm (collectInTyp seen τ) a) v
-  | .assertEq τ _ a b r =>
+  | .assertEq τ _ a b _ r =>
     collectInTypedTerm
       (collectInTypedTerm (collectInTypedTerm (collectInTyp seen τ) a) b) r
   | .ioSetInfo τ _ c k i l r =>
@@ -740,7 +741,7 @@ def collectCalls (decls : Typed.Decls)
     collectCalls decls (collectCalls decls seen c) k
   | .proj _ _ a _ | .get _ _ a _ | .slice _ _ a _ _ => collectCalls decls seen a
   | .set _ _ a _ v => collectCalls decls (collectCalls decls seen a) v
-  | .assertEq _ _ a b r =>
+  | .assertEq _ _ a b _ r =>
     collectCalls decls (collectCalls decls (collectCalls decls seen a) b) r
   | .ioSetInfo _ _ c k i l r =>
     collectCalls decls
@@ -803,9 +804,9 @@ def substInTypedTerm (subst : Global → Option Typ) : Typed.Term → Typed.Term
   | .store τ e a => .store (Typ.instantiate subst τ) e (substInTypedTerm subst a)
   | .load τ e a => .load (Typ.instantiate subst τ) e (substInTypedTerm subst a)
   | .ptrVal τ e a => .ptrVal (Typ.instantiate subst τ) e (substInTypedTerm subst a)
-  | .assertEq τ e a b r =>
+  | .assertEq τ e a b msg r =>
     .assertEq (Typ.instantiate subst τ) e (substInTypedTerm subst a)
-              (substInTypedTerm subst b) (substInTypedTerm subst r)
+              (substInTypedTerm subst b) msg (substInTypedTerm subst r)
   | .ioGetInfo τ e c k =>
     .ioGetInfo (Typ.instantiate subst τ) e
       (substInTypedTerm subst c) (substInTypedTerm subst k)
diff --git a/Ix/Aiur/Compiler/Lower.lean b/Ix/Aiur/Compiler/Lower.lean
index 9092cee6b..275090c4b 100644
--- a/Ix/Aiur/Compiler/Lower.lean
+++ b/Ix/Aiur/Compiler/Lower.lean
@@ -267,10 +267,10 @@ def toIndex
     let ptr ← expectIdx layoutMap bindings ptr
     pushOp (.load size ptr) size
   | .ptrVal _ _ ptr => toIndex layoutMap bindings ptr
-  | .assertEq _ _ a b ret => do
+  | .assertEq _ _ a b msg ret => do
     let a ← toIndex layoutMap bindings a
     let b ← toIndex layoutMap bindings b
-    modify fun stt => { stt with ops := stt.ops.push (.assertEq a b) }
+    modify fun stt => { stt with ops := stt.ops.push (.assertEq a b msg) }
     toIndex layoutMap bindings ret
   | .ioGetInfo _ _ channel key => do
     let channel ← expectIdx layoutMap bindings channel
@@ -477,10 +477,10 @@ def Concrete.Term.compile
     let term ← term.mapM (toIndex layoutMap bindings)
     modify fun stt => { stt with ops := stt.ops.push (.debug label term) }
     ret.compile returnTyp layoutMap bindings yieldCtrl
-  | .assertEq _ _ a b ret => do
+  | .assertEq _ _ a b msg ret => do
     let a ← toIndex layoutMap bindings a
     let b ← toIndex layoutMap bindings b
-    modify fun stt => { stt with ops := stt.ops.push (.assertEq a b) }
+    modify fun stt => { stt with ops := stt.ops.push (.assertEq a b msg) }
     ret.compile returnTyp layoutMap bindings yieldCtrl
   | .ioSetInfo _ _ channel key idx len ret => do
     let channel ← toIndex layoutMap bindings channel
diff --git a/Ix/Aiur/Compiler/Match.lean b/Ix/Aiur/Compiler/Match.lean
index f976f9769..205e0dee7 100644
--- a/Ix/Aiur/Compiler/Match.lean
+++ b/Ix/Aiur/Compiler/Match.lean
@@ -369,7 +369,8 @@ def typedToSimple : Term → Simple.Term
   | .store τ e a => .store τ e (typedToSimple a)
   | .load τ e a => .load τ e (typedToSimple a)
   | .ptrVal τ e a => .ptrVal τ e (typedToSimple a)
-  | .assertEq τ e a b r => .assertEq τ e (typedToSimple a) (typedToSimple b) (typedToSimple r)
+  | .assertEq τ e a b msg r =>
+    .assertEq τ e (typedToSimple a) (typedToSimple b) msg (typedToSimple r)
   | .ioGetInfo τ e c k => .ioGetInfo τ e (typedToSimple c) (typedToSimple k)
   | .ioSetInfo τ e c k i l r =>
     .ioSetInfo τ e (typedToSimple c) (typedToSimple k) (typedToSimple i)
diff --git a/Ix/Aiur/Compiler/Simple.lean b/Ix/Aiur/Compiler/Simple.lean
index 31b4d1f96..6727df5e9 100644
--- a/Ix/Aiur/Compiler/Simple.lean
+++ b/Ix/Aiur/Compiler/Simple.lean
@@ -103,11 +103,11 @@ def simplifyTypedTerm (decls : Source.Decls) : Term → Except CheckError Term
         | some sub => do pure (some (← simplifyTypedTerm decls sub))
       let r' ← simplifyTypedTerm decls r
       pure (.debug τ e l t' r')
-  | .assertEq τ e a b r => do
+  | .assertEq τ e a b msg r => do
       let a' ← simplifyTypedTerm decls a
       let b' ← simplifyTypedTerm decls b
       let r' ← simplifyTypedTerm decls r
-      pure (.assertEq τ e a' b' r')
+      pure (.assertEq τ e a' b' msg r')
   | .ioSetInfo τ e c k i l r => do
       let c' ← simplifyTypedTerm decls c
       let k' ← simplifyTypedTerm decls k
diff --git a/Ix/Aiur/Interpret.lean b/Ix/Aiur/Interpret.lean
index c964cae6e..7b6717367 100644
--- a/Ix/Aiur/Interpret.lean
+++ b/Ix/Aiur/Interpret.lean
@@ -318,10 +318,13 @@ partial def interp (decls : Decls) (bindings : Bindings) : Term → InterpM Valu
       match ← interp decls bindings t with
       | .pointer _ n => return .field (G.ofNat n)
       | _            => throwErr "ptrVal: expected pointer"
-  | .assertEq t1 t2 ret => do
+  | .assertEq t1 t2 msg ret => do
       let v1 ← interp decls bindings t1
       let v2 ← interp decls bindings t2
-      if v1 != v2 then throwErr s!"assertEq: {v1} ≠ {v2}"
+      if v1 != v2 then
+        match msg with
+        | some m => throwErr s!"assertEq: {v1} ≠ {v2} ({m})"
+        | none   => throwErr s!"assertEq: {v1} ≠ {v2}"
       interp decls bindings ret
   | .u8BitDecomposition t => do
       match ← interp decls bindings t with
diff --git a/Ix/Aiur/Meta.lean b/Ix/Aiur/Meta.lean
index 5f05b393e..745dee630 100644
--- a/Ix/Aiur/Meta.lean
+++ b/Ix/Aiur/Meta.lean
@@ -183,7 +183,7 @@ syntax "set" "(" aiur_trm ", " num ", " aiur_trm ")"                        : ai
 syntax "store" "(" aiur_trm ")"                                              : aiur_trm
 syntax "load" "(" aiur_trm ")"                                               : aiur_trm
 syntax "ptr_val" "(" aiur_trm ")"                                            : aiur_trm
-syntax "assert_eq!" "(" aiur_trm ", " aiur_trm ")" ";" (aiur_trm)?         : aiur_trm
+syntax "assert_eq!" "(" aiur_trm ", " aiur_trm (", " str)? ")" ";" (aiur_trm)? : aiur_trm
 syntax aiur_trm ": " aiur_typ                                               : aiur_trm
 syntax "io_get_info" "(" aiur_trm ", " aiur_trm ")"                          : aiur_trm
 syntax "io_set_info" "(" aiur_trm ", " aiur_trm ", " aiur_trm ", " aiur_trm ")" ";"
@@ -310,8 +310,11 @@ partial def elabTrm : ElabStxCat `aiur_trm
     mkAppM ``Source.Term.load #[← elabTrm a]
   | `(aiur_trm| ptr_val($a:aiur_trm)) => do
     mkAppM ``Source.Term.ptrVal #[← elabTrm a]
-  | `(aiur_trm| assert_eq!($a:aiur_trm, $b:aiur_trm); $[$ret:aiur_trm]?) => do
-    mkAppM ``Source.Term.assertEq #[← elabTrm a, ← elabTrm b, ← elabRet ret]
+  | `(aiur_trm| assert_eq!($a:aiur_trm, $b:aiur_trm $[, $msg:str]?); $[$ret:aiur_trm]?) => do
+    let msgExpr ← match msg with
+      | some m => mkAppM ``Option.some #[mkStrLit m.getString]
+      | none   => mkAppOptM ``Option.none #[Lean.mkConst ``String]
+    mkAppM ``Source.Term.assertEq #[← elabTrm a, ← elabTrm b, msgExpr, ← elabRet ret]
   | `(aiur_trm| $v:aiur_trm : $t:aiur_typ) => do
     mkAppM ``Source.Term.ann #[← elabTyp t, ← elabTrm v]
   | `(aiur_trm| io_get_info($ch:aiur_trm, $key:aiur_trm)) => do
@@ -500,11 +503,11 @@ where
     | `(aiur_trm| ptr_val($a:aiur_trm)) => do
       let a ← replaceToken old new a
       `(aiur_trm| ptr_val($a))
-    | `(aiur_trm| assert_eq!($a:aiur_trm, $b:aiur_trm); $[$ret:aiur_trm]?) => do
+    | `(aiur_trm| assert_eq!($a:aiur_trm, $b:aiur_trm $[, $msg:str]?); $[$ret:aiur_trm]?) => do
       let a ← replaceToken old new a
       let b ← replaceToken old new b
       let ret' ← ret.mapM $ replaceToken old new
-      `(aiur_trm| assert_eq!($a, $b); $[$ret']?)
+      `(aiur_trm| assert_eq!($a, $b $[, $msg]?); $[$ret']?)
     | `(aiur_trm| $v:aiur_trm : $t:aiur_typ) => do
       let v ← replaceToken old new v
       `(aiur_trm| $v : $t)
diff --git a/Ix/Aiur/Semantics/BytecodeEval.lean b/Ix/Aiur/Semantics/BytecodeEval.lean
index db275e1a4..63b23c089 100644
--- a/Ix/Aiur/Semantics/BytecodeEval.lean
+++ b/Ix/Aiur/Semantics/BytecodeEval.lean
@@ -197,7 +197,7 @@ def evalOp (t : Bytecode.Toplevel) (fuel : Nat) (op : Op) (st : EvalState) :
     let ptrG ← readIdx st ptr
     let vs ← memLoad st size ptrG.val.toNat
     pure (appendMap st vs)
-  | .assertEq as bs => do
+  | .assertEq as bs _ => do
     let aGs ← readIdxs st as
     let bGs ← readIdxs st bs
     if aGs == bGs then .ok st else .error .assertFailed
diff --git a/Ix/Aiur/Semantics/BytecodeFfi.lean b/Ix/Aiur/Semantics/BytecodeFfi.lean
index f1ad0888e..fcd920e71 100644
--- a/Ix/Aiur/Semantics/BytecodeFfi.lean
+++ b/Ix/Aiur/Semantics/BytecodeFfi.lean
@@ -184,17 +184,11 @@ private opaque checkAddrWithEnv' : @& Bytecode.Toplevel →
   @& Bytecode.FunIdx → @& EnvHandle → @& ByteArray → Bool →
     Except String ExecuteResult
 
-@[extern "rs_aiur_toplevel_shard_check_with_env"]
-private opaque shardCheckWithEnv' : @& Bytecode.Toplevel →
-  @& Bytecode.FunIdx → @& EnvHandle → @& ByteArray → Bool →
-    Except String ExecuteResult
-
 /-- Per-claim check against a Rust-owned `EnvHandle`. `useBytecode`
     selects the generic Aiur bytecode interpreter
     (`Bytecode.Toplevel.execute`) over the codegen'd IxVM kernel
     (`execute_ixvm`); useful for tight iteration loops on Lean-side
-    IxVM source where regenerating `crates/ixvm-codegen/src/aiur_ixvm.rs` and
-    recompiling Rust is too slow. -/
+    IxVM source where regenerating the Rust kernel is too slow. -/
 def checkAddrWithEnv (toplevel : @& Bytecode.Toplevel)
   (funIdx : @& Bytecode.FunIdx) (envHandle : @& EnvHandle)
   (addrBytes : ByteArray) (useBytecode : Bool := false)
@@ -202,8 +196,14 @@ def checkAddrWithEnv (toplevel : @& Bytecode.Toplevel)
   (checkAddrWithEnv' toplevel funIdx envHandle addrBytes useBytecode).map
     fun r => (r.output, .ofArrays r.ioData r.ioMap, r.queryCounts)
 
-/-- Per-shard check against a Rust-owned `EnvHandle`. See
-    `checkAddrWithEnv` for `useBytecode` semantics. -/
+@[extern "rs_aiur_toplevel_shard_check_with_env"]
+private opaque shardCheckWithEnv' : @& Bytecode.Toplevel →
+  @& Bytecode.FunIdx → @& EnvHandle → @& ByteArray → Bool →
+    Except String ExecuteResult
+
+/-- Per-shard check with the witness shape (wrapper-augmented byte
+    scope for the kernel's kernel-side blake3'd projection addrs). Claim and
+    digest are identical to `shardCheckWithEnv`'s. -/
 def shardCheckWithEnv (toplevel : @& Bytecode.Toplevel)
   (funIdx : @& Bytecode.FunIdx) (envHandle : @& EnvHandle)
   (ownedBlob : ByteArray) (useBytecode : Bool := false)
diff --git a/Ix/Aiur/Semantics/SourceEval.lean b/Ix/Aiur/Semantics/SourceEval.lean
index 0f5b72ea0..3e49839c5 100644
--- a/Ix/Aiur/Semantics/SourceEval.lean
+++ b/Ix/Aiur/Semantics/SourceEval.lean
@@ -337,14 +337,17 @@ def interp (decls : Decls) (fuel : Nat) (bindings : Bindings)
         match v with
         | .pointer _ n => .ok (.field (G.ofNat n), st')
         | _            => .error (.typeMismatch "ptrVal")
-  | .assertEq t1 t2 ret =>
+  | .assertEq t1 t2 msg ret =>
       match interp decls fuel bindings t1 st with
       | .error e => .error e
       | .ok (v1, st1) =>
         match interp decls fuel bindings t2 st1 with
         | .error e => .error e
         | .ok (v2, st2) =>
-          if v1 != v2 then .error (.typeMismatch "assertEq")
+          if v1 != v2 then
+            .error (.typeMismatch (match msg with
+              | some m => s!"assertEq: {m}"
+              | none   => "assertEq"))
           else interp decls fuel bindings ret st2
   | .u8BitDecomposition t =>
       match interp decls fuel bindings t st with
diff --git a/Ix/Aiur/Stages/Bytecode.lean b/Ix/Aiur/Stages/Bytecode.lean
index 18c6a5399..d9a8f30ca 100644
--- a/Ix/Aiur/Stages/Bytecode.lean
+++ b/Ix/Aiur/Stages/Bytecode.lean
@@ -27,7 +27,7 @@ inductive Op
   | call : FunIdx → Array ValIdx → (outputSize : Nat) → (unconstrained : Bool) → Op
   | store : Array ValIdx → Op
   | load : (size : Nat) → ValIdx → Op
-  | assertEq : Array ValIdx → Array ValIdx → Op
+  | assertEq : Array ValIdx → Array ValIdx → Option String → Op
   | ioGetInfo : ValIdx → Array ValIdx → Op
   | ioSetInfo : ValIdx → Array ValIdx → ValIdx → ValIdx → Op
   | ioRead : ValIdx → ValIdx → Nat → Op
diff --git a/Ix/Aiur/Stages/Codegen.lean b/Ix/Aiur/Stages/Codegen.lean
index dca4c3e3f..5fdf8fde2 100644
--- a/Ix/Aiur/Stages/Codegen.lean
+++ b/Ix/Aiur/Stages/Codegen.lean
@@ -338,7 +338,7 @@ def Op.outputCount : Op → Nat
   | .call _ _ outSize _ => outSize
   | .store _ => 1
   | .load size _ => size
-  | .assertEq _ _ => 0
+  | .assertEq _ _ _ => 0
   | .ioGetInfo _ _ => 2
   | .ioSetInfo _ _ _ _ => 0
   | .ioRead _ _ len => len
@@ -440,7 +440,16 @@ private def emitLoad (out : Nat) (size : Nat) (ptr : ValIdx) : Array RustStmt :=
   return stmts
 
 /-- `Op::AssertEq`: mirror execute.rs lines 346-363. -/
-private def emitAssertEq (xs ys : Array ValIdx) : Array RustStmt :=
+private def emitAssertEq (xs ys : Array ValIdx) (msg : Option String) :
+    Array RustStmt :=
+  -- `msg` becomes the `Option<String>` on `ExecError::AssertEqMismatch`.
+  -- Escape quotes and backslashes so an arbitrary label stays a valid
+  -- Rust string literal.
+  let msgLit := match msg with
+    | some m =>
+      let esc := (m.replace "\\" "\\\\").replace "\"" "\\\""
+      s!"Some(\"{esc}\".to_string())"
+    | none => "None"
   if xs.size != ys.size then
     #[.exprStmt (.lit s!"return Err(ExecError::AssertEqLengthMismatch \{ lhs: {xs.size}, rhs: {ys.size} })")]
   else Id.run do
@@ -448,7 +457,7 @@ private def emitAssertEq (xs ys : Array ValIdx) : Array RustStmt :=
     for (x, y) in xs.zip ys do
       stmts := stmts.push (.ifStmt
         (.binop "!=" (valVar x) (valVar y))
-        #[.exprStmt (.lit s!"return Err(ExecError::AssertEqMismatch \{ lhs: __v_{x}.as_canonical_u64(), rhs: __v_{y}.as_canonical_u64() })")]
+        #[.exprStmt (.lit s!"return Err(ExecError::AssertEqMismatch \{ lhs: __v_{x}.as_canonical_u64(), rhs: __v_{y}.as_canonical_u64(), msg: {msgLit} })")]
         none)
     return stmts
 
@@ -681,7 +690,7 @@ def emitOp (out : Nat) (op : Op) : Array RustStmt :=
   | .call callee args outSz opUn => emitCall out callee args outSz opUn
   | .store vs => emitStore out vs
   | .load size ptr => emitLoad out size ptr
-  | .assertEq xs ys => emitAssertEq xs ys
+  | .assertEq xs ys msg => emitAssertEq xs ys msg
   | .ioGetInfo ch key => emitIOGetInfo out ch key
   | .ioSetInfo ch key idx len => emitIOSetInfo ch key idx len
   | .ioRead ch idx len => emitIORead out ch idx len
diff --git a/Ix/Aiur/Stages/Concrete.lean b/Ix/Aiur/Stages/Concrete.lean
index 4dc85fb95..3a8235cc5 100644
--- a/Ix/Aiur/Stages/Concrete.lean
+++ b/Ix/Aiur/Stages/Concrete.lean
@@ -68,7 +68,8 @@ inductive Term : Type where
   | store (typ : Typ) (escapes : Bool) (a : Term) : Term
   | load (typ : Typ) (escapes : Bool) (a : Term) : Term
   | ptrVal (typ : Typ) (escapes : Bool) (a : Term) : Term
-  | assertEq (typ : Typ) (escapes : Bool) (a : Term) (b : Term) (r : Term) : Term
+  | assertEq (typ : Typ) (escapes : Bool) (a : Term) (b : Term)
+      (msg : Option String) (r : Term) : Term
   | ioGetInfo (typ : Typ) (escapes : Bool) (c k : Term) : Term
   | ioSetInfo (typ : Typ) (escapes : Bool) (c k i l r : Term) : Term
   | ioRead (typ : Typ) (escapes : Bool) (c i : Term) (n : Nat) : Term
@@ -102,7 +103,7 @@ def Term.typ : Term → Typ
   | .add t _ _ _ | .sub t _ _ _ | .mul t _ _ _ | .eqZero t _ _
   | .proj t _ _ _ | .get t _ _ _ | .slice t _ _ _ _ | .set t _ _ _ _
   | .store t _ _ | .load t _ _ | .ptrVal t _ _
-  | .assertEq t _ _ _ _ | .ioGetInfo t _ _ _ | .ioSetInfo t _ _ _ _ _ _
+  | .assertEq t _ _ _ _ _ | .ioGetInfo t _ _ _ | .ioSetInfo t _ _ _ _ _ _
   | .ioRead t _ _ _ _ | .ioWrite t _ _ _ _
   | .u8BitDecomposition t _ _ | .u8ShiftLeft t _ _ | .u8ShiftRight t _ _
   | .u8Xor t _ _ _ | .u8Add t _ _ _ | .u8Mul t _ _ _ | .u8Sub t _ _ _
@@ -121,7 +122,7 @@ def Term.escapes : Term → Bool
   | .add _ e _ _ | .sub _ e _ _ | .mul _ e _ _ | .eqZero _ e _
   | .proj _ e _ _ | .get _ e _ _ | .slice _ e _ _ _ | .set _ e _ _ _
   | .store _ e _ | .load _ e _ | .ptrVal _ e _
-  | .assertEq _ e _ _ _ | .ioGetInfo _ e _ _ | .ioSetInfo _ e _ _ _ _ _
+  | .assertEq _ e _ _ _ _ | .ioGetInfo _ e _ _ | .ioSetInfo _ e _ _ _ _ _
   | .ioRead _ e _ _ _ | .ioWrite _ e _ _ _
   | .u8BitDecomposition _ e _ | .u8ShiftLeft _ e _ | .u8ShiftRight _ e _
   | .u8Xor _ e _ _ | .u8Add _ e _ _ | .u8Mul _ e _ _ | .u8Sub _ e _ _
diff --git a/Ix/Aiur/Stages/Simple.lean b/Ix/Aiur/Stages/Simple.lean
index 207f71a8f..fed94ac61 100644
--- a/Ix/Aiur/Stages/Simple.lean
+++ b/Ix/Aiur/Stages/Simple.lean
@@ -64,7 +64,8 @@ inductive Term : Type where
   | store (typ : Typ) (escapes : Bool) (a : Term) : Term
   | load (typ : Typ) (escapes : Bool) (a : Term) : Term
   | ptrVal (typ : Typ) (escapes : Bool) (a : Term) : Term
-  | assertEq (typ : Typ) (escapes : Bool) (a : Term) (b : Term) (r : Term) : Term
+  | assertEq (typ : Typ) (escapes : Bool) (a : Term) (b : Term)
+      (msg : Option String) (r : Term) : Term
   | ioGetInfo (typ : Typ) (escapes : Bool) (c k : Term) : Term
   | ioSetInfo (typ : Typ) (escapes : Bool) (c k i l r : Term) : Term
   | ioRead (typ : Typ) (escapes : Bool) (c i : Term) (n : Nat) : Term
@@ -99,7 +100,7 @@ def Term.typ : Term → Typ
   | .add t _ _ _ | .sub t _ _ _ | .mul t _ _ _ | .eqZero t _ _
   | .proj t _ _ _ | .get t _ _ _ | .slice t _ _ _ _ | .set t _ _ _ _
   | .store t _ _ | .load t _ _ | .ptrVal t _ _
-  | .assertEq t _ _ _ _ | .ioGetInfo t _ _ _ | .ioSetInfo t _ _ _ _ _ _
+  | .assertEq t _ _ _ _ _ | .ioGetInfo t _ _ _ | .ioSetInfo t _ _ _ _ _ _
   | .ioRead t _ _ _ _ | .ioWrite t _ _ _ _
   | .u8BitDecomposition t _ _ | .u8ShiftLeft t _ _ | .u8ShiftRight t _ _
   | .u8Xor t _ _ _ | .u8Add t _ _ _ | .u8Mul t _ _ _ | .u8Sub t _ _ _
@@ -118,7 +119,7 @@ def Term.escapes : Term → Bool
   | .add _ e _ _ | .sub _ e _ _ | .mul _ e _ _ | .eqZero _ e _
   | .proj _ e _ _ | .get _ e _ _ | .slice _ e _ _ _ | .set _ e _ _ _
   | .store _ e _ | .load _ e _ | .ptrVal _ e _
-  | .assertEq _ e _ _ _ | .ioGetInfo _ e _ _ | .ioSetInfo _ e _ _ _ _ _
+  | .assertEq _ e _ _ _ _ | .ioGetInfo _ e _ _ | .ioSetInfo _ e _ _ _ _ _
   | .ioRead _ e _ _ _ | .ioWrite _ e _ _ _
   | .u8BitDecomposition _ e _ | .u8ShiftLeft _ e _ | .u8ShiftRight _ e _
   | .u8Xor _ e _ _ | .u8Add _ e _ _ | .u8Mul _ e _ _ | .u8Sub _ e _ _
diff --git a/Ix/Aiur/Stages/Source.lean b/Ix/Aiur/Stages/Source.lean
index d55316e32..7fcea876b 100644
--- a/Ix/Aiur/Stages/Source.lean
+++ b/Ix/Aiur/Stages/Source.lean
@@ -414,7 +414,7 @@ inductive Term
   | load : Term → Term
   | ptrVal : Term → Term
   | ann : Typ → Term → Term
-  | assertEq : Term → Term → (ret : Term) → Term
+  | assertEq : Term → Term → (msg : Option String) → (ret : Term) → Term
   | ioGetInfo : (channel : Term) → (key : Term) → Term
   | ioSetInfo : (channel : Term) → (key : Term) → (idx : Term) → (len : Term) → (ret : Term) → Term
   | ioRead : (channel : Term) → (idx : Term) → (len : Nat) → Term
@@ -659,9 +659,9 @@ def Term.freshen (cnt : Nat) (subst : Std.HashMap Local Local) :
   | .load a => let (cnt, a') := Term.freshen cnt subst a; (cnt, .load a')
   | .ptrVal a => let (cnt, a') := Term.freshen cnt subst a; (cnt, .ptrVal a')
   | .ann τ a => let (cnt, a') := Term.freshen cnt subst a; (cnt, .ann τ a')
-  | .assertEq a b c =>
+  | .assertEq a b msg c =>
     let (cnt, a') := Term.freshen cnt subst a; let (cnt, b') := Term.freshen cnt subst b; let (cnt, c') := Term.freshen cnt subst c
-    (cnt, .assertEq a' b' c')
+    (cnt, .assertEq a' b' msg c')
   | .ioGetInfo c k => let (cnt, c') := Term.freshen cnt subst c; let (cnt, k') := Term.freshen cnt subst k; (cnt, .ioGetInfo c' k')
   | .ioSetInfo c k i l rv =>
     let (cnt, c') := Term.freshen cnt subst c; let (cnt, k') := Term.freshen cnt subst k; let (cnt, i') := Term.freshen cnt subst i
@@ -734,7 +734,8 @@ def Term.inlineCallSites : Term → List (Global × Nat)
   | .u8LessThan a b | .u32LessThan a b | .u8ChainRotr7 a b | .u8ChainRotr4 a b
   | .unconstrainedBigUintDivMod a b | .u8RangeCheck a b | .ioGetInfo a b =>
     a.inlineCallSites ++ b.inlineCallSites
-  | .assertEq a b c | .ioWrite a b c => a.inlineCallSites ++ b.inlineCallSites ++ c.inlineCallSites
+  | .assertEq a b _ c => a.inlineCallSites ++ b.inlineCallSites ++ c.inlineCallSites
+  | .ioWrite a b c => a.inlineCallSites ++ b.inlineCallSites ++ c.inlineCallSites
   | .ioSetInfo c k i l rv =>
     c.inlineCallSites ++ k.inlineCallSites ++ i.inlineCallSites ++ l.inlineCallSites ++ rv.inlineCallSites
   | .ioRead a b _ => a.inlineCallSites ++ b.inlineCallSites
@@ -827,9 +828,9 @@ def Term.expandOnce (done : Std.HashMap Global (List Local × Term)) (cnt : Nat)
   | .load a => let (cnt, a') := Term.expandOnce done cnt a; (cnt, .load a')
   | .ptrVal a => let (cnt, a') := Term.expandOnce done cnt a; (cnt, .ptrVal a')
   | .ann τ a => let (cnt, a') := Term.expandOnce done cnt a; (cnt, .ann τ a')
-  | .assertEq a b c =>
+  | .assertEq a b msg c =>
     let (cnt, a') := Term.expandOnce done cnt a; let (cnt, b') := Term.expandOnce done cnt b
-    let (cnt, c') := Term.expandOnce done cnt c; (cnt, .assertEq a' b' c')
+    let (cnt, c') := Term.expandOnce done cnt c; (cnt, .assertEq a' b' msg c')
   | .ioGetInfo c k => let (cnt, c') := Term.expandOnce done cnt c; let (cnt, k') := Term.expandOnce done cnt k; (cnt, .ioGetInfo c' k')
   | .ioSetInfo c k i l rv =>
     let (cnt, c') := Term.expandOnce done cnt c; let (cnt, k') := Term.expandOnce done cnt k
@@ -913,10 +914,10 @@ def Term.hoistLets : Term → Term :=
   | .app g args mode =>
     let (fs, cs) := Term.peelListLets (args.attach.map fun ⟨x, _⟩ => Term.hoistLets x)
     Term.wrapLets fs (.app g cs mode)
-  | .assertEq a b c =>
+  | .assertEq a b msg c =>
     let (fs, cs) := Term.peelListLets [Term.hoistLets a, Term.hoistLets b, Term.hoistLets c]
     match cs with
-    | [a, b, c] => Term.wrapLets fs (.assertEq a b c)
+    | [a, b, c] => Term.wrapLets fs (.assertEq a b msg c)
     | _ => t
   | .ioSetInfo a b c d e =>
     let (fs, cs) := Term.peelListLets [Term.hoistLets a, Term.hoistLets b, Term.hoistLets c, Term.hoistLets d, Term.hoistLets e]
@@ -1078,7 +1079,9 @@ partial def Term.collectGlobals (acc : Std.HashSet Global) : Term → Std.HashSe
   | .u8RangeCheck a b | .unconstrainedBigUintDivMod a b | .ioGetInfo a b =>
     b.collectGlobals (a.collectGlobals acc)
   | .set a _ v => v.collectGlobals (a.collectGlobals acc)
-  | .assertEq a b r | .ioWrite a b r =>
+  | .assertEq a b _ r =>
+    r.collectGlobals (b.collectGlobals (a.collectGlobals acc))
+  | .ioWrite a b r =>
     r.collectGlobals (b.collectGlobals (a.collectGlobals acc))
   | .ioSetInfo c k i l r =>
     r.collectGlobals (l.collectGlobals (i.collectGlobals
diff --git a/Ix/Aiur/Stages/Typed.lean b/Ix/Aiur/Stages/Typed.lean
index 1fa46bc4d..f20718f95 100644
--- a/Ix/Aiur/Stages/Typed.lean
+++ b/Ix/Aiur/Stages/Typed.lean
@@ -40,7 +40,8 @@ inductive Term : Type where
   | store (typ : Typ) (escapes : Bool) (a : Term) : Term
   | load (typ : Typ) (escapes : Bool) (a : Term) : Term
   | ptrVal (typ : Typ) (escapes : Bool) (a : Term) : Term
-  | assertEq (typ : Typ) (escapes : Bool) (a : Term) (b : Term) (r : Term) : Term
+  | assertEq (typ : Typ) (escapes : Bool) (a : Term) (b : Term)
+      (msg : Option String) (r : Term) : Term
   | ioGetInfo (typ : Typ) (escapes : Bool) (c k : Term) : Term
   | ioSetInfo (typ : Typ) (escapes : Bool) (c k i l r : Term) : Term
   | ioRead (typ : Typ) (escapes : Bool) (c i : Term) (n : Nat) : Term
@@ -75,7 +76,7 @@ def Term.typ : Term → Typ
   | .add t _ _ _ | .sub t _ _ _ | .mul t _ _ _ | .eqZero t _ _
   | .proj t _ _ _ | .get t _ _ _ | .slice t _ _ _ _ | .set t _ _ _ _
   | .store t _ _ | .load t _ _ | .ptrVal t _ _
-  | .assertEq t _ _ _ _ | .ioGetInfo t _ _ _ | .ioSetInfo t _ _ _ _ _ _
+  | .assertEq t _ _ _ _ _ | .ioGetInfo t _ _ _ | .ioSetInfo t _ _ _ _ _ _
   | .ioRead t _ _ _ _ | .ioWrite t _ _ _ _
   | .u8BitDecomposition t _ _ | .u8ShiftLeft t _ _ | .u8ShiftRight t _ _
   | .u8Xor t _ _ _ | .u8Add t _ _ _ | .u8Mul t _ _ _ | .u8Sub t _ _ _
@@ -94,7 +95,7 @@ def Term.escapes : Term → Bool
   | .add _ e _ _ | .sub _ e _ _ | .mul _ e _ _ | .eqZero _ e _
   | .proj _ e _ _ | .get _ e _ _ | .slice _ e _ _ _ | .set _ e _ _ _
   | .store _ e _ | .load _ e _ | .ptrVal _ e _
-  | .assertEq _ e _ _ _ | .ioGetInfo _ e _ _ | .ioSetInfo _ e _ _ _ _ _
+  | .assertEq _ e _ _ _ _ | .ioGetInfo _ e _ _ | .ioSetInfo _ e _ _ _ _ _
   | .ioRead _ e _ _ _ | .ioWrite _ e _ _ _
   | .u8BitDecomposition _ e _ | .u8ShiftLeft _ e _ | .u8ShiftRight _ e _
   | .u8Xor _ e _ _ | .u8Add _ e _ _ | .u8Mul _ e _ _ | .u8Sub _ e _ _
diff --git a/Ix/AuxGen/BRecOn.lean b/Ix/AuxGen/BRecOn.lean
index dd716dcb3..a6f20b6b6 100644
--- a/Ix/AuxGen/BRecOn.lean
+++ b/Ix/AuxGen/BRecOn.lean
@@ -1069,7 +1069,7 @@ def buildTypeBreconFvar (ci : Nat) (recVal : RecursorVal)
     (breconName : Name) (_all0 : Name) (belowNames : Array Name)
     (nClasses : Nat) (maps : AddrMaps) : KBridgeM (Array BRecOnDef) := do
   -- canon_kenv is populated by `populateCanonKenvWithBelow` between
-  -- Phase 2 and Phase 3: PUnit, PProd, parent inductives, canonical
+  -- and Phase 3: PUnit, PProd, parent inductives, canonical
   -- `.below` types.
   let nParams := recVal.numParams
   let nMotives := recVal.numMotives
diff --git a/Ix/Cli/CheckCmd.lean b/Ix/Cli/CheckCmd.lean
index 26cf8e72e..6192b52e3 100644
--- a/Ix/Cli/CheckCmd.lean
+++ b/Ix/Cli/CheckCmd.lean
@@ -28,6 +28,7 @@ public import Ix.AssumptionTree
 public import Ix.Claim
 public import Ix.Common
 public import Ix.IxVM
+public import Ix.IxVM.Toplevel
 public import Ix.IxVM.ClaimHarness
 public import Ix.Ixon
 public import Ix.Meta
@@ -84,7 +85,7 @@ def loadClaimAndTrees (claimHex : String) :
 def mkWitness (addr : Address) (ixonEnv : Ixon.Env) :
     IO IxVM.ClaimHarness.ClaimWitness := do
   IO.ofExcept <|
-    IxVM.ClaimHarness.buildClaimWitness ixonEnv (Ix.Claim.check addr none)
+    IxVM.ClaimHarness.buildClaimWitness ixonEnv (Ix.Claim.check addr none) {}
 
 /-- Compute + emit per-circuit stats. With `statsOut = none` prints to
     stdout; with `some path` redirects stdout to the file for the
@@ -286,6 +287,10 @@ def forEachClaim
     -- can share one handle across many names; this arm cannot
     -- without a shared-env preprocess pass.)
     let runOneByName (name : Lean.Name) (label : String) : IO UInt32 := do
+      -- the kernel env loader: also seeds the constants the kernel fabricates
+      -- during reduction (Bool/Nat ctors, String-literal ctor form),
+      -- whose bytes must be in ch 2 even when the target's proof body
+      -- never references them.
       let ixonEnv ← IxVM.ClaimHarness.loadIxonEnv name env
       let addr ← IxVM.ClaimHarness.lookupAddr ixonEnv name
       let claim := Ix.Claim.check addr none
@@ -393,7 +398,12 @@ private def blockAddrOf (addr : Address) (c : Ixon.Constant) : Address :=
   | _ => addr
 
 /-- Owned constants of a shard: every env constant whose check-schedule block
-    is in `blocks`. -/
+    is in `blocks`.
+
+    Constants whose bytes do not parse are skipped and therefore owned by
+    NOBODY. That is safe only because `shardsCover` fails the run when any
+    exist, so this is never reached with one present; without that gate a
+    silent skip here means a constant no shard ever checks. -/
 def ownedConstsForBlocks (ixonEnv : Ixon.Env) (blocks : Array Address) : Array Address := Id.run do
   let blockSet : Std.HashSet Address := blocks.foldl (·.insert ·) {}
   let mut o : Array Address := #[]
@@ -499,8 +509,17 @@ def shardsCover (ixonEnv : Ixon.Env) (shards : Array (Array Address)) : IO Bool
   -- assign every const to a shard via its block; count + detect unowned.
   let mut counts : Array Nat := Array.replicate shards.size 0
   let mut unowned : Nat := 0
+  let mut unparsed : Nat := 0
   for (addr, lc) in ixonEnv.consts do
-    let some c := lc.get? | continue
+    -- A constant whose bytes do not parse must FAIL the gate, not be
+    -- skipped. `.ixe` loading is lazy and `LazyConstant.get?` discards
+    -- the error, so such a constant sits in `consts` with its key
+    -- present: skipping it assigned it to no shard, counted it as
+    -- neither owned nor unowned, and still included it in the "covers
+    -- all N consts" total below. It would also enter a referring
+    -- shard's frontier, since that admits an edge on key presence
+    -- without parsing — an assumption no shard discharges.
+    let some c := lc.get? | unparsed := unparsed + 1; continue
     match blockToShard.get? (blockAddrOf addr c) with
     | some k => counts := counts.modify k (· + 1)  -- total: no-op if out of range
     | none => unowned := unowned + 1
@@ -511,7 +530,10 @@ def shardsCover (ixonEnv : Ixon.Env) (shards : Array (Array Address)) : IO Bool
     IO.eprintln s!"[shards] FAIL: {dup} block(s) owned by >1 shard (not disjoint)"
   if unowned != 0 then
     IO.eprintln s!"[shards] FAIL: {unowned} const(s) with no owning shard (coverage gap)"
-  let ok := dup == 0 && unowned == 0
+  if unparsed != 0 then
+    IO.eprintln s!"[shards] FAIL: {unparsed} const(s) whose bytes do not parse \
+      (cannot be assigned to a shard)"
+  let ok := dup == 0 && unowned == 0 && unparsed == 0
   if ok then
     IO.println s!"[shards] OK: partition covers all {ixonEnv.consts.size} consts, disjoint"
   pure ok
diff --git a/Ix/Cli/CodegenCmd.lean b/Ix/Cli/CodegenCmd.lean
index 783645b2c..f958c4bee 100644
--- a/Ix/Cli/CodegenCmd.lean
+++ b/Ix/Cli/CodegenCmd.lean
@@ -29,6 +29,7 @@ public import Cli
 public import Ix.Aiur.Compiler
 public import Ix.Aiur.Stages.Codegen
 public import Ix.IxVM
+public import Ix.IxVM.Toplevel
 public import Ix.MultiStark
 
 public section
@@ -45,6 +46,10 @@ structure Target where
   outPath : String
 
 def targets : List Target := [
+  -- the generated kernel is the kernel. Every consumer of
+  -- `execute_ixvm` must select the SAME toplevel for its function-index
+  -- table (CheckCmd / ProveCmd / VerifyCmd), or `funIdx` lookups
+  -- resolve against a different function set than the generated code.
   { label := "ixvm", source := IxVM.ixVM,
     outPath := "crates/ixvm-codegen/src/aiur_ixvm.rs" },
   { label := "multi-stark", source := MultiStark.multiStark,
diff --git a/Ix/Cli/ProveCmd.lean b/Ix/Cli/ProveCmd.lean
index 6319c362f..76aa385d4 100644
--- a/Ix/Cli/ProveCmd.lean
+++ b/Ix/Cli/ProveCmd.lean
@@ -33,6 +33,7 @@ public import Ix.Claim
 public import Ix.Cli.CheckCmd
 public import Ix.Common
 public import Ix.IxVM
+public import Ix.IxVM.Toplevel
 public import Ix.IxVM.ClaimHarness
 public import Ix.Ixon
 public import Ix.Store
diff --git a/Ix/Cli/VerifyCmd.lean b/Ix/Cli/VerifyCmd.lean
index f24bcb623..3c1943f9d 100644
--- a/Ix/Cli/VerifyCmd.lean
+++ b/Ix/Cli/VerifyCmd.lean
@@ -16,6 +16,7 @@ public import Ix.Aiur.Protocol
 public import Ix.Claim
 public import Ix.Common
 public import Ix.IxVM
+public import Ix.IxVM.Toplevel
 public import Ix.IxVM.ClaimHarness
 public import Ix.Store
 public import Ix.Cli.CheckCmd
diff --git a/Ix/Common.lean b/Ix/Common.lean
index c2756fe77..83a9b3a52 100644
--- a/Ix/Common.lean
+++ b/Ix/Common.lean
@@ -397,6 +397,22 @@ def collectDependencies (name : Lean.Name) (consts : Lean.ConstMap) : ConstList
   let (constList, _) := collectDependenciesAux const consts [(name, const)] default
   constList
 
+/-- Bulk closure: `collectDependencies` over many roots SHARING one
+    visited set, so overlapping closures walk once instead of once per
+    root. For n roots over a common library the per-root variant is
+    O(n × closure); this is O(union closure). -/
+def collectDependenciesMany (names : Array Lean.Name)
+    (consts : Lean.ConstMap) : ConstList := Id.run do
+  let mut acc : ConstList := []
+  let mut seen : Lean.NameHashSet := default
+  for n in names do
+    if seen.contains n then continue
+    let some const := consts.find? n | continue
+    let (acc', seen') := collectDependenciesAux const consts ((n, const) :: acc) seen
+    acc := acc'
+    seen := seen'
+  return acc
+
 end Lean
 
 /-- Format a duration in milliseconds with appropriate unit suffix.
diff --git a/Ix/CompileM.lean b/Ix/CompileM.lean
index 1e4daa1e7..9dff0ef19 100644
--- a/Ix/CompileM.lean
+++ b/Ix/CompileM.lean
@@ -243,9 +243,21 @@ def modifyGetBlockState (f : BlockState → α × BlockState) : CompileM α := d
 def withBlockEnv (f : BlockEnv → BlockEnv) (m : CompileM α) : CompileM α :=
   withReader (fun (env, blockEnv) => (env, f blockEnv)) m
 
-/-- Set universe context. -/
-def withUnivCtx (univCtx : List Name) : CompileM α → CompileM α :=
-  withBlockEnv fun env => { env with univCtx }
+/-- Set the universe-parameter context, dropping the universe cache.
+
+    `compileUniv` keys `univCache` by the `Level` alone, but a
+    `Level.param` compiles to `Univ.var i` where `i` is the parameter's
+    POSITION in `univCtx` — so the result depends on this context. The
+    cache lives for a whole block while each member compiles under its
+    own `levelParams`, so without this a member whose context orders the
+    same parameter name differently would inherit the earlier member's
+    index: a silently wrong constant under a correct-looking name, with
+    no error. The expression cache is cleared per constant for the same
+    reason (`clearExprCache`); the Rust mirror instead widens the key to
+    `(level, univ_params_key)`. -/
+def withUnivCtx (univCtx : List Name) : CompileM α → CompileM α := fun act => do
+  modifyBlockState fun c => { c with univCache := {} }
+  withBlockEnv (fun env => { env with univCtx }) act
 
 /-- Set mutual context. -/
 def withMutCtx (mutCtx : MutCtx) : CompileM α → CompileM α :=
diff --git a/Ix/IxVM.lean b/Ix/IxVM.lean
index 23788db2a..45c6b898d 100644
--- a/Ix/IxVM.lean
+++ b/Ix/IxVM.lean
@@ -4,175 +4,15 @@ public import Ix.IxVM.Core
 public import Ix.IxVM.ByteStream
 public import Ix.IxVM.Blake3
 public import Ix.IxVM.RBTreeMap
-public import Ix.IxVM.Ingress
 public import Ix.IxVM.Ixon
 public import Ix.IxVM.IxonSerialize
 public import Ix.IxVM.IxonDeserialize
-public import Ix.IxVM.Convert
-public import Ix.IxVM.KernelTypes
-public import Ix.IxVM.Kernel.Levels
-public import Ix.IxVM.Kernel.Primitive
-public import Ix.IxVM.Kernel.Subst
-public import Ix.IxVM.Kernel.Whnf
-public import Ix.IxVM.Kernel.Infer
-public import Ix.IxVM.Kernel.DefEq
-public import Ix.IxVM.Kernel.Inductive
-public import Ix.IxVM.Kernel.CanonicalCheck
-public import Ix.IxVM.Kernel.Check
-public import Ix.IxVM.Kernel.Claim
 public import Ix.IxVM.ClaimHarness
 
 public section
 
 namespace IxVM
 
-def entrypoints := ⟦
-  /- # Test entrypoints -/
-
-  pub fn ixon_serde_test(n: G) {
-    match n {
-      0 => (),
-      _ =>
-        let n_minus_1 = n - 1;
-        let (idx, len) = io_get_info(0, [n_minus_1]);
-        let bytes = #read_byte_stream(0, idx, len);
-        let (const, rest) = get_constant(bytes);
-        assert_eq!(load(rest), ListNode.Nil);
-        let bytes2 = put_constant(const, store(ListNode.Nil));
-        assert_eq!(bytes, bytes2);
-        ixon_serde_test(n_minus_1),
-    }
-  }
-
-  fn level_cmp_tests() {
-    let zero = store(KLevelNode.Zero);
-    let p0 = store(KLevelNode.Param(0));
-    let p1 = store(KLevelNode.Param(1));
-    let succ_p0 = store(KLevelNode.Succ(p0));
-    let succ_zero = store(KLevelNode.Succ(zero));
-
-    -- Zero ≤ anything
-    assert_eq!(level_leq(zero, p0), 1);
-
-    -- Param(u) ≤ Param(u) (reflexivity)
-    assert_eq!(level_leq(p0, p0), 1);
-
-    -- Param(u) ≤ Param(v) fails (u ≠ v, set u > v)
-    assert_eq!(level_leq(p0, p1), 0);
-
-    -- Succ(u) ≤ Succ(u) (peel both succs)
-    assert_eq!(level_leq(succ_p0, succ_p0), 1);
-
-    -- Succ(u) ≤ u fails (u+1 > u at any assignment)
-    assert_eq!(level_leq(succ_p0, p0), 0);
-
-    -- Param(u) ≤ Succ(Param(u)) (u ≤ u+1)
-    assert_eq!(level_leq(p0, succ_p0), 1);
-
-    -- max(u, v) ≤ max(u, v) (reflexivity via distribution)
-    let max_uv = store(KLevelNode.Max(p0, p1));
-    assert_eq!(level_leq(max_uv, max_uv), 1);
-
-    -- u ≤ max(u, v)
-    assert_eq!(level_leq(p0, max_uv), 1);
-
-    -- max(u, v) ≤ u fails
-    assert_eq!(level_leq(max_uv, p0), 0);
-
-    -- imax(u, v) ≤ max(u, v)
-    let imax_uv = store(KLevelNode.IMax(p0, p1));
-    assert_eq!(level_leq(imax_uv, max_uv), 1);
-
-    -- max(u, v) ≤ imax(u, v) fails
-    assert_eq!(level_leq(max_uv, imax_uv), 0);
-
-    -- u+1 = max(1, imax(u+1, u)): equal for all σ (case-split fix)
-    let a = succ_p0;
-    let b = store(KLevelNode.Max(
-      succ_zero,
-      store(KLevelNode.IMax(succ_p0, p0))));
-    assert_eq!(level_equal(a, b), 1);
-
-    -- imax(u, u) = u
-    assert_eq!(level_equal(store(KLevelNode.IMax(p0, p0)), p0), 1);
-
-    -- max(u, 0) = u
-    assert_eq!(level_equal(store(KLevelNode.Max(p0, zero)), p0), 1);
-
-    -- level_imax reduces imax(u, 1+v) to max(u, 1+v) and imax(u, 0) to 0
-    let succ_v = store(KLevelNode.Succ(p1));
-    assert_eq!(level_eq(
-      level_imax(p0, succ_v),
-      store(KLevelNode.Max(p0, succ_v))), 1);
-
-    assert_eq!(level_eq(
-      level_imax(p0, zero),
-      zero), 1);
-  }
-
-  pub fn kernel_unit_tests() {
-    level_cmp_tests()
-  }
-
-  /- # Benchmark entrypoints -/
-
-  pub fn ixon_serde_blake3_bench(n: G) {
-    match n {
-      0 => (),
-      _ =>
-        let n_minus_1 = n - 1;
-        let (idx, len) = io_get_info(0, [n_minus_1]);
-        let bytes = #read_byte_stream(0, idx, len);
-        let (const, rest) = get_constant(bytes);
-        assert_eq!(load(rest), ListNode.Nil);
-        let bytes2 = put_constant(const, store(ListNode.Nil));
-        assert_eq!(blake3(bytes), blake3(bytes2));
-        ixon_serde_blake3_bench(n_minus_1),
-    }
-  }
-⟧
-
-/-- Build the FULL IxVM Aiur toplevel: every merged module, every entry
-    point — including the test/bench entries (`blake3_test`,
-    `sha256_bench`, `rbtree_map_test`, `kernel_unit_tests`,
-    `ixon_serde_blake3_bench`, …). Use this only for harnesses that run
-    those entries; production systems build from `ixVM` (pruned), so
-    test-only circuits never widen a committed kernel system. -/
-def ixVMFull : Except Aiur.Global Aiur.Source.Toplevel := do
-  let vm ← core.merge byteStream
-  let vm ← vm.merge blake3
-  let vm ← vm.merge rbTreeMap
-  let vm ← vm.merge ixon
-  let vm ← vm.merge ixonSerialize
-  let vm ← vm.merge ixonDeserialize
-  let vm ← vm.merge convert
-  let vm ← vm.merge ingress
-  let vm ← vm.merge kernelTypes
-  let vm ← vm.merge levels
-  let vm ← vm.merge primitive
-  let vm ← vm.merge subst
-  let vm ← vm.merge whnf
-  let vm ← vm.merge infer
-  let vm ← vm.merge defEq
-  let vm ← vm.merge inductive_check
-  let vm ← vm.merge canonicalCheck
-  let vm ← vm.merge check
-  let vm ← vm.merge claim
-  vm.merge entrypoints
-
-/-- The production IxVM kernel toplevel: `ixVMFull` pruned to the closure
-    of the two kernel entry points. The byte loaders inside `ingress`
-    recompute blake3 over every IOBuffer read and assert the digest
-    matches the address key — required for `verify_claim`'s soundness.
-    `verify_const` (the arena-test subject-only entrypoint) goes through
-    the same loaders since the IxVM kernel only has one storage
-    convention. Pruning drops the test/bench entries and their exclusive
-    call closures — every compiled function is a committed circuit whose
-    openings pad every proof, so dead entries cost real proof bytes. -/
-def ixVM : Except Aiur.Global Aiur.Source.Toplevel := do
-  let vm ← ixVMFull
-  pure (vm.prune [`verify_claim, `verify_const])
-
 end IxVM
 
 end
diff --git a/Ix/IxVM/Blake3.lean b/Ix/IxVM/Blake3.lean
index 1648bc12d..cfaad39ef 100644
--- a/Ix/IxVM/Blake3.lean
+++ b/Ix/IxVM/Blake3.lean
@@ -59,7 +59,8 @@ def blake3 := ⟦
        h[5][0], h[5][1], h[5][2], h[5][3],
        h[6][0], h[6][1], h[6][2], h[6][3],
        h[7][0], h[7][1], h[7][2], h[7][3]],
-      expected);
+      expected,
+      "blake3 of the supplied bytes != the address they were fetched under");
   }
 
   -- Hash `bytes` and intern the digest into the Store. Returned pointer is
diff --git a/Ix/IxVM/ByteStream.lean b/Ix/IxVM/ByteStream.lean
index 4fa485e77..f1ab554f0 100644
--- a/Ix/IxVM/ByteStream.lean
+++ b/Ix/IxVM/ByteStream.lean
@@ -283,9 +283,26 @@ def byteStream := ⟦
   -- Flatten a [U8; 8] (U64 little-endian bytes) into a single G via
   -- b0 + 256 * b1 + ... + 256^6 * b6. The most significant byte (b7) must be zero;
   -- this is enforced by assert_eq!, limiting the range to 7 bytes (< 2^56).
+  --
+  -- INJECTIVITY IS CONDITIONAL ON THE CALLER. `[U8; 8]` is nominal typing,
+  -- not a constraint — `u8_from_field_unsafe` mints a `U8` holding any
+  -- field element — so this function alone does NOT pin a unique input
+  -- for a given output. With unchecked bytes the sum is satisfiable many
+  -- ways (`b1 = k`, `b0 = x - 256k`). Only when every byte is
+  -- range-checked does `b7 = 0` bound the value by 2^56 - 1, which is
+  -- below Goldilocks `p`, so the sum cannot wrap and the decomposition is
+  -- unique.
+  --
+  -- Callers relying on that uniqueness must therefore supply
+  -- range-checked bytes, and must not lose the `b7 = 0` assert: widening
+  -- this to a full u64 would silently break them, since 8-byte strings
+  -- are not injective into the field (a value and value + p collide).
+  -- `Ingress.idx_to_u64` is one such caller — it pins a projection index
+  -- whose bytes are hashed into a member's content address.
   fn flatten_u64(x: [U8; 8]) -> G {
     let [b0, b1, b2, b3, b4, b5, b6, b7] = x;
-    assert_eq!(to_field(b7), 0);
+    assert_eq!(to_field(b7), 0,
+      "u64 -> field: value exceeds 2^56 (top byte must be zero)");
     to_field(b0) + 0x100 * to_field(b1) + 0x10000 * to_field(b2)
       + 0x1000000 * to_field(b3) + 0x100000000 * to_field(b4)
       + 0x10000000000 * to_field(b5) + 0x1000000000000 * to_field(b6)
diff --git a/Ix/IxVM/ClaimHarness.lean b/Ix/IxVM/ClaimHarness.lean
index 52cb70c4f..0fdf11739 100644
--- a/Ix/IxVM/ClaimHarness.lean
+++ b/Ix/IxVM/ClaimHarness.lean
@@ -5,6 +5,7 @@ public import Ix.Claim
 public import Ix.AssumptionTree
 public import Ix.CompileM
 public import Ix.Common
+public import Ix.Tc.Primitive
 
 public section
 
@@ -21,16 +22,17 @@ The harness handles every step the Aiur side cannot:
    return an `Ixon.Env` representing the constants' transitive
    closure.
 
-2. **Closure layout**: `closureFrom` follows `Constant.refs` (+
-   projection block addresses) from a target address. Mirrors the
-   Aiur kernel's `load_with_deps` so the IOBuffer carries exactly
-   what the kernel will look up.
+2. **Closure layout**: `closureFrom` follows `Constant.refs`,
+   projection block addresses, and the derived Muts→wrapper edges from
+   a target address, then seeds primitive bytes — the same scope the
+   Rust witness builder computes (`witness_scope` over
+   `Env::bfs_closure`), so the IOBuffer carries everything the kernel
+   can reach.
 
-3. **IOBuffer population**: `addEntries` seeds the constants, blobs,
-   and Defn reducibility hints under their content-addressed keys
-   (`addr`, `addr ++ [0]`, `addr ++ [1]`). The Aiur kernel reads via
-   `io_get_info` + `#read_byte_stream` and blake3-verifies each
-   payload against its key.
+3. **IOBuffer population**: `addEntries` seeds the constants, blobs, and
+   Defn reducibility hints on their own channels, each keyed by the
+   address it belongs to. See the "IxVM IOBuffer interface" section
+   below for the channel table and the binding argument.
 
 4. **Witness construction**: `buildClaimWitness` serializes any
    `Ix.Claim`, seeds the bytes at `key = blake3(claim)`, pulls in the
@@ -55,12 +57,6 @@ keys.
 -/
 namespace IxVM.ClaimHarness
 
-/-- Run the Lean → Ixon FFI pipeline for `name`'s transitive closure. -/
-def loadIxonEnv (name : Lean.Name) (leanEnv : Lean.Environment) : IO Ixon.Env := do
-  let constList := Lean.collectDependencies name leanEnv.constants
-  let rawEnv ← Ix.CompileM.rsCompileEnvFFI constList
-  pure rawEnv.toEnv
-
 /-- Resolve a Lean name to its `Ixon.Env` `Address`, or fail with a
     descriptive `IO` error. Used by every claim/witness builder that
     starts from a Lean name. -/
@@ -69,6 +65,35 @@ def lookupAddr (ixonEnv : Ixon.Env) (name : Lean.Name) : IO Address :=
   | some addr => pure addr
   | none => throw <| IO.userError s!"{name} not found in Ixon environment"
 
+/-- Nat / Bool constants the kernel's primitive dispatch synthesizes at
+    reduction time (nat literal → succ chain, nat_beq/ble → Bool.true/
+    false). Bytes for these MUST live in ch 2 for the kernel's `get_ci` to
+    load them — but they may not be dependencies of the target's proof
+    body. Seed them into the compile list. -/
+def synthesizedPrimNames : Array Lean.Name :=
+  #[`Bool.true, `Bool.false, `Nat.zero, `Nat.succ, `Bool,
+    -- String-literal ctor expansion (str_lit_to_ctor): the def_eq
+    -- Tier 1c / proj-head expansion fabricates Consts of these.
+    `String, `String.ofList, `Char, `Char.ofNat, `List.nil, `List.cons]
+
+/-- Variant of loadIxonEnv: also seeds the constants the kernel's kernel
+    fabricates during reduction (Bool.true/false + Nat.zero/succ), so
+    their bytes are always in ch 2 even when the target's proof body
+    doesn't textually reference them. -/
+def loadIxonEnv (name : Lean.Name) (leanEnv : Lean.Environment) :
+    IO Ixon.Env := do
+  let mut seen : Lean.NameSet := {}
+  let mut deduped : Array (Lean.Name × Lean.ConstantInfo) := #[]
+  let names : Array Lean.Name := #[name] ++ synthesizedPrimNames
+  for n in names do
+    if leanEnv.constants.contains n then
+      for entry in Lean.collectDependencies n leanEnv.constants do
+        if !seen.contains entry.fst then
+          seen := seen.insert entry.fst
+          deduped := deduped.push entry
+  let rawEnv ← Ix.CompileM.rsCompileEnvFFI deduped.toList
+  pure rawEnv.toEnv
+
 /-- Compile the union of `names`'s transitive closures into one shared
     Ixon env. Drivers like `KernelArena.lean` use this to pay the
     Lean→Ixon compile cost once and then build per-target IOBuffers via
@@ -85,13 +110,65 @@ def loadSharedIxonEnv (names : Array Lean.Name) (leanEnv : Lean.Environment) :
   let rawEnv ← Ix.CompileM.rsCompileEnvFFI deduped.toList
   pure rawEnv.toEnv
 
-/-- Walk the Constant ref-graph from `target` to compute the set of
-    addresses needed to type-check it. Mirrors Aiur's `load_with_deps`:
-    follow `Constant.refs` plus the projection's `block_addr` (the parent
-    Muts wrapper) for IPrj/CPrj/RPrj/DPrj. -/
-partial def closureFrom (env : Ixon.Env) (target : Address) : Std.HashSet Address := Id.run do
+/-- The `refs` indices `e` uses as a CONSTANT: `Ref i` and the type index
+    of `Prj i`. `Str`/`Nat` index blob payloads and `Rec` resolves through
+    the block's members, so neither contributes. `Share` is not followed —
+    every shared subexpression is itself an entry of `Constant.sharing`,
+    walked separately. Mirrors `const_idxs_expr` in `Kernel/Claim.lean`. -/
+partial def constIdxsExpr : Ixon.Expr → Std.HashSet UInt64
+  | .ref i _ => {i}
+  | .prj i _ inner => (constIdxsExpr inner).insert i
+  | .app a b | .lam a b | .all a b => (constIdxsExpr a).union (constIdxsExpr b)
+  | .letE _ t v b =>
+    ((constIdxsExpr t).union (constIdxsExpr v)).union (constIdxsExpr b)
+  | _ => {}
+
+/-- The `refs` indices `c` uses as constants, over its `sharing` table and
+    every Expr its `ConstantInfo` carries. Mirrors `const_idxs_of` in
+    `Kernel/Claim.lean` and `ixon::shard_claim::const_idxs_of`. -/
+def constIdxsOf (c : Ixon.Constant) : Std.HashSet UInt64 := Id.run do
+  let mut out : Std.HashSet UInt64 := {}
+  for e in c.sharing do
+    out := out.union (constIdxsExpr e)
+  let ofDefn (d : Ixon.Definition) := (constIdxsExpr d.typ).union (constIdxsExpr d.value)
+  let ofRecr (r : Ixon.Recursor) := r.rules.foldl
+    (fun acc rule => acc.union (constIdxsExpr rule.rhs)) (constIdxsExpr r.typ)
+  let ofIndc (i : Ixon.Inductive) := i.ctors.foldl
+    (fun acc ctor => acc.union (constIdxsExpr ctor.typ)) (constIdxsExpr i.typ)
+  match c.info with
+  | .defn d => out := out.union (ofDefn d)
+  | .recr r => out := out.union (ofRecr r)
+  | .axio a => out := out.union (constIdxsExpr a.typ)
+  | .quot q => out := out.union (constIdxsExpr q.typ)
+  | .muts members =>
+    for m in members do
+      out := out.union <| match m with
+        | .defn d => ofDefn d
+        | .indc i => ofIndc i
+        | .recr r => ofRecr r
+  -- Projection wrappers carry no Exprs of their own.
+  | _ => pure ()
+  return out
+
+/-- Content address of a synthesized projection wrapper: a `Constant`
+    holding just the proj info with empty sharing/refs/univs tables,
+    serialized and blake3-hashed — the same construction compile uses
+    (and Rust `ixon::constant::*_proj_address`). -/
+def projWrapperAddr (info : Ixon.ConstantInfo) : Address :=
+  Address.blake3 (Ixon.ser (⟨info, #[], #[], #[]⟩ : Ixon.Constant))
+
+/-- Walk the Constant ref-graph from `roots` to compute the set of
+    addresses needed to type-check them. Mirrors Rust `Env::bfs_closure`:
+    follow `Constant.refs`, the projection's `block` pointer
+    (IPrj/CPrj/RPrj/DPrj), and — for a `Muts` block — every derived
+    member/constructor projection wrapper address. The wrapper edges are
+    what the kernel's lazy `get_ci` needs: it synthesizes those addrs via
+    kernel-side blake3 and faults their bytes from ch 2, and no
+    `Constant.refs` edge names them. -/
+partial def closureFromRoots (env : Ixon.Env) (roots : Array Address) :
+    Std.HashSet Address := Id.run do
   let mut visited : Std.HashSet Address := {}
-  let mut worklist : Array Address := #[target]
+  let mut worklist : Array Address := roots
   while !worklist.isEmpty do
     let addr := worklist.back!
     worklist := worklist.pop
@@ -105,6 +182,20 @@ partial def closureFrom (env : Ixon.Env) (target : Address) : Std.HashSet Addres
     match c.info with
     | .rPrj p | .dPrj p => worklist := worklist.push p.block
     | _ => pure ()
+    if let .muts members := c.info then
+      let mut i : UInt64 := 0
+      for m in members do
+        let info : Ixon.ConstantInfo := match m with
+          | .defn _ => .dPrj ⟨i, addr⟩
+          | .indc _ => .iPrj ⟨i, addr⟩
+          | .recr _ => .rPrj ⟨i, addr⟩
+        worklist := worklist.push (projWrapperAddr info)
+        if let .indc ind := m then
+          let mut cidx : UInt64 := 0
+          for _ in ind.ctors do
+            worklist := worklist.push (projWrapperAddr (.cPrj ⟨i, cidx, addr⟩))
+            cidx := cidx + 1
+        i := i + 1
   return visited
 
 /-- Build the `ixon_serde_test` / `ixon_serde_blake3_bench` IOBuffer:
@@ -126,39 +217,66 @@ private def hintToG : Lean.ReducibilityHints → Aiur.G
 
 /-! ## IxVM IOBuffer interface
 
-The host seeds blake3-keyed payloads on six channels; the Aiur kernel
-consumes them via `io_get_info` + `#read_byte_stream`. One value shape
-per channel — no overloading, no in-band discriminators.
-
-Tiered by access pattern (matches kernel runtime order):
-
-| Tier   | Channel | Purpose                  | Key (32 G)              | Value shape       |
-|--------|---------|--------------------------|-------------------------|-------------------|
-| Ctrl   | 0       | claim wire bytes         | `blake3(claim_bytes)`   | claim bytes       |
-| Ctrl   | 1       | assumption tree bytes    | `tree.root`             | tree bytes        |
-| Const  | 2       | constant wire bytes      | const addr              | const bytes       |
-| Const  | 3       | Defn reducibility hint   | Defn addr               | single G          |
-| Blob   | 4       | blob discriminator       | addr                    | one byte (1=const, 0=blob) |
-| Blob   | 5       | blob raw bytes           | blob addr               | raw bytes         |
-
-Tier 1 fires once per `verify_claim` invocation (claim + optional tree).
-Tier 2 fires per constant traversed during `load_with_deps`. Tier 3
-fires per blob ref encountered during `build_ref_idxs_and_blobs`.
-
-Soundness:
-* ch 0/1/2/5 — every byte stream is blake3-verified by the kernel
-  against its content-addressed key.
-* ch 3 — semantically optional; controls WHNF reduction heuristic
-  only, def-eq is sound either way.
-* ch 4 — sound by erasure-correctness: a lying discriminator flips
-  the const/blob decision and the wrong-path load downstream fails
-  (a "const" blob triggers a ch 2 read returning empty → blake3
-  verify against the non-empty addr fails; a "blob" const dangles
-  references → typecheck fail).
+This section is the normative description of the host↔kernel interface.
+The host seeds payloads on five channels (0–4); the Aiur kernel consumes
+them via `io_get_info` + `#read_byte_stream`. Each channel carries one
+value shape and each key is the content address of the value it maps to
+— no overloading, no in-band discriminators.
+
+| Channel | Purpose                | Key (32 G)            | Value shape  |
+|---------|------------------------|-----------------------|--------------|
+| 0       | claim wire bytes       | `blake3(claim_bytes)` | claim bytes  |
+| 1       | assumption tree bytes  | `tree.root`           | tree bytes   |
+| 2       | constant wire bytes    | const addr            | const bytes  |
+| 3       | Defn reducibility hint | Defn addr             | single G     |
+| 4       | blob raw bytes         | blob addr             | raw bytes    |
+
+An address is seeded on ch 2 iff it is a constant, and on ch 4 iff it is
+a blob. The two sets are disjoint and neither carries an entry on the
+other's channel.
+
+Access pattern. Channels 0 and 1 are read once per `verify_claim`: the
+claim itself, then its assumption tree if the variant carries one.
+Channels 2, 3, and 4 are read on demand — `get_ci` faults a constant
+the first time the check touches its address, and the reducibility hint
+and blob payload follow from that same fault. Nothing is walked up
+front, so what actually gets read is a subset of what the host seeds.
+
+Binding. On channels 0, 2, and 4 the kernel re-hashes the bytes it read
+and asserts blake3 equality against the key, so the host cannot
+substitute a payload. Channel 1 is bound the same way in effect but by a
+different derivation: the kernel parses the tree and recomputes its
+merkle root, which must equal the key — the tree's serialization is not
+itself hashed. Channel 3 is advisory: it selects a WHNF reduction
+heuristic and def-eq is sound under any value, so a lying hint costs
+performance, never soundness.
+
+`idx` and `len` from `io_get_info` are UNCONSTRAINED prover witness —
+`Op::IOGetInfo` emits no constraint and no lookup. They are safe to use
+for one thing only: locating bytes that are then bound. Read the wrong
+span and the re-hash fails. **Never branch on `idx` or `len`** — a
+control-flow decision taken on them is a decision the prover makes, and
+it is taken before anything is bound.
+
+Blob-vs-constant is derived from the bytes, not asked of the buffer.
+Within a constant's `refs`, an entry is a blob iff some Expr node
+references it as one — `Str(i)` / `Nat(i)` index blob payloads,
+`Ref(i)` / `Prj(i, ..)` index constants — and `refs` is exactly the
+union of those four (`crates/ixon/src/constant.rs`). An address reached
+from outside any Expr (a claim target, a block address) is a constant
+reference by Ixon convention. The same BYTES may be readable as both a
+constant and a Nat or utf-8 string, so this Expr context is the only
+correct discriminator; byte inspection cannot replace it. Blob-ness is
+therefore a POSITIVE property computed from hash-bound bytes, and every
+address lacking it is a constant that must be walked.
 
 Channel numbers MUST stay in sync with the inlined `io_get_info` /
-`#read_byte_stream` channel literals in `Ix/IxVM/Ingress.lean` and
-`Ix/IxVM/Kernel/Claim.lean`.
+`#read_byte_stream` literals in `Ix/IxVM/Ingress.lean` and
+`Ix/IxVM/Kernel/Claim.lean`. Channel 0 is reused with a different key
+shape by the test and benchmark entrypoints (`blake3_test`,
+`ixon_serde_test`, …); those never run in the same execution as
+`verify_claim`, so the one-shape-per-channel rule holds for every
+production path.
 -/
 
 /-- Insert all per-address entries for `addr`s satisfying `keep` into
@@ -173,14 +291,10 @@ def addEntries (ixonEnv : Ixon.Env) (keep : Address → Bool)
     let bytes := lc.rawBytes
     let key : Array Aiur.G := addr.hash.data.map .ofUInt8
     ioBuffer := ioBuffer.extend 2 key (bytes.data.map .ofUInt8)
-    -- Discriminator: this addr resolves to a constant.
-    ioBuffer := ioBuffer.extend 4 key #[.ofNat 1]
   for (addr, rawBytes) in ixonEnv.blobs do
     if !keep addr then continue
     let key : Array Aiur.G := addr.hash.data.map .ofUInt8
-    ioBuffer := ioBuffer.extend 5 key (rawBytes.data.map fun b => .ofNat b.toNat)
-    -- Discriminator: this addr resolves to a blob.
-    ioBuffer := ioBuffer.extend 4 key #[.ofNat 0]
+    ioBuffer := ioBuffer.extend 4 key (rawBytes.data.map fun b => .ofNat b.toNat)
   for (addr, hints) in ixonEnv.anonHints do
     if !keep addr then continue
     let key : Array Aiur.G := addr.hash.data.map .ofUInt8
@@ -218,28 +332,28 @@ private def seedTreeAt (root : Address)
     .ok (ioBuffer.extend 1 (addrKey tree.root) (bytes.data.map .ofUInt8))
   | none => .error s!"no assumption tree supplied for root {root}"
 
-/-- Build the witness for `verify_claim` against `claim`.
-
-    `trees` is a caller-supplied map of merkle-root → tree; every root
-    that appears in the claim (assumption root, env root, contains
-    tree root) MUST have an entry. `Ix.AssumptionTree.canonical` builds
-    the canonical sorted+padded shape if you start from a leaf list.
-
-    Per-variant IOBuffer payload:
-    - `Check addr none`: closure of `addr`.
-    - `Check addr (some r)`: closure of `addr` + assumption tree at `r`.
-    - `Eval i o asm`: closure of `i ∪ o` (+ optional asm tree).
-    - `CheckEnv root asm`: full env entries + env-tree at `root`
-      (+ optional asm tree).
-    - `Reveal comm info`: closure of `comm`. Info bytes ride inside
-      the claim bytes already.
-    - `Contains tree target`: tree at `tree`. No const ingest.
-
-    Returns `Except String ClaimWitness`: error message names the
-    missing assumption root when applicable.
-
-    Eval-claim invocations currently hit the placeholder
-    `assert_eq!(0,1)` arm of `verify_claim` at proving time. -/
+/-- The full witness byte scope for `target`: the closure of `target`
+    together with every primitive address present in `env`, all as walk
+    ROOTS. Mirrors Rust `witness_scope`.
+
+    Primitives are seeded because the kernel fabricates
+    `Const(Std(prim_addr))` refs inline via `mk_prim_const`
+    (Whnf/Infer/NatPrim), which triggers a load bypassing the ref walk —
+    those addresses need not appear in any `Constant.refs`.
+
+    Their closures are walked, not just their own bytes: def-eq
+    delta-unfolds primitive BODIES (the `strAppend*` arena fixtures do
+    exactly this), and a body's refs are reachable from nowhere else in
+    the scope. Shipping the address alone aborts those with `invalid IO
+    key`. -/
+def closureFrom (env : Ixon.Env) (target : Address) : Std.HashSet Address :=
+  closureFromRoots env
+    (#[target] ++ Ix.Tc.primAddrSet.toArray.filter env.consts.contains)
+
+/-- Serializes `claim`, seeds its bytes at `key = blake3(claim)`, and
+    populates the IOBuffer with the `closureFrom` byte scope of every
+    address the claim variant names (plus any caller-supplied
+    `AssumptionTree`s under their merkle roots). -/
 def buildClaimWitness (env : Ixon.Env) (claim : Ix.Claim)
     (trees : Std.HashMap Address Ix.AssumptionTree := {}) :
     Except String ClaimWitness := do
@@ -271,11 +385,18 @@ def buildClaimWitness (env : Ixon.Env) (claim : Ix.Claim)
   return { funcName := `verify_claim
            input := digestKey, inputIOBuffer := ioBuffer }
 
-/-- Reconstruct a shard's `CheckEnv` claim, its reference closure, and the
-    assumption trees (env-root + optional frontier) — everything **except** the
-    IO buffer. Deterministic in `owned` (canonical trees sort addresses), so the
-    claim digest reproduces exactly what `prove`d — used to bind a proof to a
-    shard during verification, cheaply (no buffer serialization). -/
+/-- the kernel shard claim with a THIN frontier: asm = the DIRECT out-of-owned
+    walk edges (refs + Prj→block) of the owned constants, not the full
+    `closure ∖ owned`. the kernel's env walk exits the shard only through a
+    direct external edge and stops there, so everything below the first
+    layer is dead weight in the asm tree. Deterministic in
+    `(env, owned)` — canonical trees sort addresses — so prove/verify
+    digests agree. Every edge — `refs` and the `Prj → block` edge alike —
+    is admitted only when it is outside `owned` AND present in
+    `env.consts`, matching `ixon::shard_claim::frontier_of`. An edge absent
+    from `env.consts` is not something the kernel walk can reach, so
+    including it would inflate the asm tree and break digest agreement
+    between the Rust prover and this verifier. -/
 def shardCheckEnvClaim (env : Ixon.Env) (owned : Array Address) :
     Except String (Ix.Claim × Std.HashSet Address × Std.HashMap Address Ix.AssumptionTree) := do
   let ownedSet : Std.HashSet Address := owned.foldl (·.insert ·) {}
@@ -285,19 +406,48 @@ def shardCheckEnvClaim (env : Ixon.Env) (owned : Array Address) :
       for x in (closureFrom env a).toArray do
         s := s.insert x
     return s
-  let frontier : Array Address :=
-    closure.toArray.filter (fun a => !ownedSet.contains a)
-  let some envTree := Ix.AssumptionTree.canonical closure.toArray
-    | .error "shardCheckEnvClaim: empty shard closure"
+  let frontier : Array Address := Id.run do
+    let mut fs : Std.HashSet Address := {}
+    for o in owned do
+      match env.getConst? o with
+      | none => pure ()
+      | some c =>
+        -- Only the indices some Expr uses as a constant are walk edges,
+        -- matching the kernel's `env_walk_refs`. A `refs` entry no Expr
+        -- names as a constant is never walked in-circuit, so admitting it
+        -- would put a phantom member in the frontier.
+        let used := constIdxsOf c
+        for (r, i) in c.refs.zipIdx do
+          if used.contains i.toUInt64 && !ownedSet.contains r
+              && env.consts.contains r then
+            fs := fs.insert r
+        let blockOpt : Option Address := match c.info with
+          | .iPrj p => some p.block
+          | .cPrj p => some p.block
+          | .rPrj p => some p.block
+          | .dPrj p => some p.block
+          | _ => none
+        match blockOpt with
+        | some b =>
+          if !ownedSet.contains b && env.consts.contains b then
+            fs := fs.insert b
+        | none => pure ()
+    return fs.toArray
+  let some ownedTree := Ix.AssumptionTree.canonical owned
+    | .error "shardCheckEnvClaim: empty owned set"
   let asmTree? := Ix.AssumptionTree.canonical frontier
-  let claim := Ix.Claim.checkEnv envTree.root (asmTree?.map (·.root))
+  let claim := Ix.Claim.checkEnv ownedTree.root (asmTree?.map (·.root))
   let mut trees : Std.HashMap Address Ix.AssumptionTree :=
-    ({} : Std.HashMap Address Ix.AssumptionTree).insert envTree.root envTree
+    ({} : Std.HashMap Address Ix.AssumptionTree).insert ownedTree.root ownedTree
   match asmTree? with
   | some asmTree => trees := trees.insert asmTree.root asmTree
   | none => pure ()
   pure (claim, closure, trees)
 
+/-- Variant of `buildShardCheckEnvWitness`: THIN frontier asm (see
+    `shardCheckEnvClaim`) with the `closureFrom` byte scope, which
+    carries the IPrj/CPrj/RPrj/DPrj wrappers the kernel's `get_ci`
+    synthesizes via kernel-side blake3 as forward Muts→wrapper edges. -/
 def buildShardCheckEnvWitness (env : Ixon.Env) (owned : Array Address) :
     Except String (Ix.Claim × ClaimWitness) := do
   let (claim, closure, trees) ← shardCheckEnvClaim env owned
@@ -305,9 +455,7 @@ def buildShardCheckEnvWitness (env : Ixon.Env) (owned : Array Address) :
   let digestKey := addrKey (Address.blake3 claimBytes)
   let mut ioBuffer : Aiur.IOBuffer := default
   ioBuffer := ioBuffer.extend 0 digestKey (claimBytes.data.map .ofUInt8)
-  -- Ship only the shard closure (consts + blobs + Defn hints).
   ioBuffer := addEntries env closure.contains ioBuffer
-  -- Seed the env-root and (when present) frontier assumption trees.
   for (root, _) in trees do
     ioBuffer ← seedTreeAt root trees ioBuffer
   return (claim, { funcName := `verify_claim
@@ -319,11 +467,9 @@ def buildShardCheckEnvWitness (env : Ixon.Env) (owned : Array Address) :
 def envCanonicalTree (env : Ixon.Env) : Option Ix.AssumptionTree :=
   Ix.AssumptionTree.canonical (env.consts.keys.toArray)
 
-/-- Build the witness for the `verify_const` Aiur entrypoint.
-    Subject-only typecheck — transitive deps are trusted, not
-    re-verified. Not a claim path (no claim-digest discipline). Used
-    by `Tests/Ix/Kernel/Arena.lean::arenaTests` where each arena
-    fixture's own well-typedness is the only signal needed. -/
+/-- Subject-only `verify_const` witness: the `closureFrom` byte scope
+    (which carries the kernel-side blake3-synthesized projection
+    wrappers as forward edges) faulted from ch 2. -/
 def buildVerifyConst (env : Ixon.Env) (target : Address) : ClaimWitness :=
   let closure := closureFrom env target
   let ioBuffer := addEntries env closure.contains default
diff --git a/Ix/IxVM/Convert.lean b/Ix/IxVM/Convert.lean
index 395689233..6f2cfed5b 100644
--- a/Ix/IxVM/Convert.lean
+++ b/Ix/IxVM/Convert.lean
@@ -6,107 +6,30 @@ public section
 namespace IxVM
 
 def convert := ⟦
-
   -- ============================================================================
-  -- Conversion input types
+  -- Convert — addr-first Ixon → KExpr / KConstantInfo
   --
-  -- A raw Ixon Constant is not self-contained: converting it requires
-  -- auxiliary data the prover must supply (ref-to-index mappings, decoded
-  -- literal values, reducibility hints, etc.).
+  -- Ixon encodes references as indices into a constant's own side tables
+  -- (`refs`, recursor tables, literal blobs). Conversion resolves each
+  -- index to the address it names, so nothing downstream carries an
+  -- index or needs a table to interpret it:
   --
-  -- ConvertCtx bundles the expression-conversion context.
-  -- ConvertKind selects what to convert plus kind-specific auxiliary data.
-  -- ConvertInput pairs the two; List‹&ConvertInput› is what convert_all consumes.
-  -- ============================================================================
-
-  -- Expression conversion context
-  -- (sharing, ref_idxs, recur_idxs, lit_blobs, univs)
+  -- - Expr.Ref(ref_idx, univs)  → Const(refs[ref_idx], levels)
+  -- - Expr.Prj(type_idx, ...)   → Proj(refs[type_idx], ...)
+  -- - Expr.Str/Nat(blob_idx)    → Lit(load_verified_blob(refs[blob_idx]))
+  -- - Expr.Rec(rec_idx, univs)  → Const(recur_addrs[rec_idx], levels),
+  --                                where recur_addrs holds one
+  --                                projection wrapper addr per member of
+  --                                the enclosing Muts block (built by
+  --                                build_recur_addrs at get_ci entry).
   --
-  -- sharing:    the constant's sharing array (for Expr.Share expansion)
-  -- ref_idxs:   maps ref array index -> kernel constant list index
-  -- recur_idxs: maps recur index -> kernel constant list index
-  -- lit_blobs:  maps blob ref index -> raw blob ByteStream
-  -- univs:      the constant's universe array
-  enum ConvertCtx {
-    Mk(List‹&Expr›, List‹G›, List‹G›, List‹ByteStream›, List‹&Univ›)
-  }
-
-  -- What to convert, with kind-specific auxiliary data
-  enum ConvertKind {
-    -- CKDefn carries Definition + reducibility hint G (packed:
-    -- 0=Opaque, 1+h=Regular(h), 0xFFFFFFFF=Abbrev). See KernelTypes.
-    CKDefn(Definition, G),
-    CKAxio(Axiom),
-    CKQuot(Quotient),
-    CKRecr(Recursor, List‹G›, Addr),
-    CKIndc(Inductive, List‹G›, Addr),
-    CKCtor(Constructor, G)
-  }
-
-  -- A fully resolved input ready for conversion
-  enum ConvertInput {
-    Mk(ConvertCtx, ConvertKind)
-  }
-
-
-  -- ============================================================================
-  -- Universe conversion: Ixon Univ -> KLevel
-  -- ============================================================================
-
-  -- Take `&Univ` (pointer) to shrink the per-row input width — Univ is a
-  -- 5-variant enum, by-value passing taxes every row with the widest
-  -- arm's columns. Mirror the `reference_aiur_pass_pointer_not_value`
-  -- pattern already used for `convert_expr(e: &Expr)`.
-  fn convert_univ(u: &Univ) -> KLevel {
-    match load(u) {
-      Univ.Zero => store(KLevelNode.Zero),
-      Univ.Succ(inner) => store(KLevelNode.Succ(convert_univ(inner))),
-      Univ.Max(a, b) => store(KLevelNode.Max(convert_univ(a), convert_univ(b))),
-      Univ.IMax(a, b) => store(KLevelNode.IMax(convert_univ(a), convert_univ(b))),
-      Univ.Var(idx) => store(KLevelNode.Param(flatten_u64(idx))),
-    }
-  }
-
-  -- Resolve a list of universe indices to a List‹KLevel›
-  fn convert_univ_idxs(idxs: List‹U64›, univs: List‹&Univ›) -> List‹KLevel› {
-    match load(idxs) {
-      ListNode.Nil => store(ListNode.Nil),
-      ListNode.Cons(idx, rest) =>
-        -- universe indices are small; walk with a field index (cheap per-step
-        -- field sub) instead of `list_lookup_u64`'s per-step U64 predecessor.
-        let u_ref = list_lookup(univs, flatten_u64(idx));
-        store(ListNode.Cons(convert_univ(u_ref), convert_univ_idxs(rest, univs))),
-    }
-  }
-
-  -- ============================================================================
-  -- Expression conversion: Ixon Expr -> KExpr
+  -- `refs` is the Constant.refs list (List<Addr>) taken straight from
+  -- Ixon. Addresses arriving here are already alpha-collapsed by the
+  -- Lean→Ixon compile, so equal terms have equal addrs and the kernel
+  -- never re-canonicalizes.
   -- ============================================================================
 
-  -- Convert a LE byte stream to KLimbs (list of U64, little-endian bignum).
-  -- Reads 8 bytes per limb, zero-padding the last limb if needed.
-  -- Strips trailing zero limbs for canonical form.
-  fn bytes_to_limbs(bytes: ByteStream) -> KLimbs {
-    let limb = bytes_to_u64_limb(bytes, [0u8; 8], 0);
-    let rest_bytes = skip_bytes(bytes, 8);
-    match limb {
-      -- If this limb is zero and there are no more bytes, return Nil
-      _ =>
-        match load(rest_bytes) {
-          ListNode.Nil =>
-            let is_zero = u64_is_zero(limb);
-            match is_zero {
-              1 => store(ListNode.Nil),
-              0 => store(ListNode.Cons(limb, store(ListNode.Nil))),
-            },
-          _ =>
-            let rest_limbs = bytes_to_limbs(rest_bytes);
-            store(ListNode.Cons(limb, rest_limbs)),
-        },
-    }
-  }
-
-  -- Read up to 8 bytes into a U64 (LE), zero-padding.
+  -- Byte→limbs conversion for Nat literals.
   fn bytes_to_u64_limb(bytes: ByteStream, acc: U64, pos: G) -> U64 {
     match pos {
       8 => acc,
@@ -129,7 +52,6 @@ def convert := ⟦
     }
   }
 
-  -- Skip n bytes from a ByteStream
   fn skip_bytes(bytes: ByteStream, n: G) -> ByteStream {
     match n {
       0 => bytes,
@@ -141,18 +63,69 @@ def convert := ⟦
     }
   }
 
+  -- Convert a LE byte stream to KLimbs (list of U64, little-endian bignum).
+  -- Reads 8 bytes per limb, zero-padding the last limb if needed.
+  -- Strips trailing zero limbs for canonical form.
+  fn bytes_to_limbs(bytes: ByteStream) -> KLimbs {
+    let limb = bytes_to_u64_limb(bytes, [0u8; 8], 0);
+    let rest_bytes = skip_bytes(bytes, 8);
+    let rest_limbs = match load(rest_bytes) {
+      ListNode.Nil => store(ListNode.Nil),
+      _ => bytes_to_limbs(rest_bytes),
+    };
+    match load(rest_limbs) {
+      ListNode.Nil =>
+        match u64_is_zero(limb) {
+          1 => store(ListNode.Nil),
+          0 => store(ListNode.Cons(limb, store(ListNode.Nil))),
+        },
+      _ => store(ListNode.Cons(limb, rest_limbs)),
+    }
+  }
+
+  -- Universe conversion.
+  fn convert_univ(u: &Univ) -> KLevel {
+    match load(u) {
+      Univ.Zero => store(KLevelNode.Zero),
+      Univ.Succ(inner) => store(KLevelNode.Succ(convert_univ(inner))),
+      Univ.Max(a, b) => store(KLevelNode.Max(convert_univ(a), convert_univ(b))),
+      Univ.IMax(a, b) => store(KLevelNode.IMax(convert_univ(a), convert_univ(b))),
+      Univ.Var(idx) => store(KLevelNode.Param(flatten_u64(idx))),
+    }
+  }
+
+  fn convert_univ_idxs(idxs: List‹U64›, univs: List‹&Univ›) -> List‹KLevel› {
+    match load(idxs) {
+      ListNode.Nil => store(ListNode.Nil),
+      ListNode.Cons(idx, rest) =>
+        let u_ref = list_lookup(univs, flatten_u64(idx));
+        store(ListNode.Cons(convert_univ(u_ref), convert_univ_idxs(rest, univs))),
+    }
+  }
+
+  -- ============================================================================
+  -- Expression conversion
+  --
+  -- Params:
+  --   e:       the Ixon Expr node.
+  --   sharing: Constant.sharing (for Expr.Share).
+  --   refs:    Constant.refs — direct List<Addr>. Ref/Prj/Str/Nat all
+  --            index into this. Under Ixon semantics, entries at Ref/Prj
+  --            positions are const addrs; entries at Str/Nat positions
+  --            are blob addrs.
+  --   univs:   Constant.univs.
+  --
+  -- Recur handling deferred to  — asserts unreachable for /.
+  -- ============================================================================
   fn convert_expr(
     e: &Expr,
     sharing: List‹&Expr›,
-    ref_idxs: List‹G›,
-    recur_idxs: List‹G›,
-    lit_blobs: List‹ByteStream›,
+    refs: List‹Addr›,
+    recur_addrs: List‹Addr›,
     univs: List‹&Univ›
   ) -> KExpr {
     match load(e) {
       Expr.Srt(univ_idx) =>
-        -- field-indexed walk (see `convert_univ_idxs`): avoids the per-step
-        -- U64 predecessor of `list_lookup_u64` on this hot universe lookup.
         let u_ref = list_lookup(univs, flatten_u64(univ_idx));
         store(KExprNode.Srt(convert_univ(u_ref))),
 
@@ -160,211 +133,195 @@ def convert := ⟦
         store(KExprNode.BVar(flatten_u64(idx))),
 
       Expr.Ref(ref_idx, univ_idxs) =>
-        let const_idx = list_lookup(ref_idxs, flatten_u64(ref_idx));
+        let ref_addr = list_lookup(refs, flatten_u64(ref_idx));
         let levels = convert_univ_idxs(univ_idxs, univs);
-        store(KExprNode.Const(const_idx, levels)),
+        store(KExprNode.Const(ref_addr, levels)),
 
       Expr.Rec(rec_idx, univ_idxs) =>
-        let const_idx = list_lookup(recur_idxs, flatten_u64(rec_idx));
+        -- Rec resolves to a member of the enclosing Muts block.
+        -- `recur_addrs` = projection wrapper addr per member,
+        -- precomputed by build_recur_addrs at get_ci entry.
+        let ref_addr = list_lookup(recur_addrs, flatten_u64(rec_idx));
         let levels = convert_univ_idxs(univ_idxs, univs);
-        store(KExprNode.Const(const_idx, levels)),
+        store(KExprNode.Const(ref_addr, levels)),
 
       Expr.Prj(type_ref_idx, field_idx, inner) =>
-        let type_idx = list_lookup(ref_idxs, flatten_u64(type_ref_idx));
+        let type_addr = list_lookup(refs, flatten_u64(type_ref_idx));
         store(KExprNode.Proj(
-          type_idx,
+          type_addr,
           flatten_u64(field_idx),
-          convert_expr(inner, sharing, ref_idxs, recur_idxs, lit_blobs, univs))),
+          convert_expr(inner, sharing, refs, recur_addrs, univs))),
 
       Expr.Str(blob_ref_idx) =>
-        let bs = list_lookup_u64(lit_blobs, blob_ref_idx);
+        let blob_addr = list_lookup(refs, flatten_u64(blob_ref_idx));
+        let bs = load_verified_blob(blob_addr);
+        -- The bytes are hash-bound to `blob_addr`, but nothing else on
+        -- this path inspects them: `k_infer_lit` types a `KLiteral.Str`
+        -- as `String` outright. Validate here, mirroring the reference
+        -- kernels' `String::from_utf8` at ingress, or a literal that is
+        -- never decoded typechecks as a `String` with no Lean
+        -- counterpart.
+        utf8_validate(bs);
         store(KExprNode.Lit(KLiteral.Str(bs))),
 
       Expr.Nat(blob_ref_idx) =>
-        let bs = list_lookup_u64(lit_blobs, blob_ref_idx);
+        let blob_addr = list_lookup(refs, flatten_u64(blob_ref_idx));
+        let bs = load_verified_blob(blob_addr);
         let limbs = bytes_to_limbs(bs);
         store(KExprNode.Lit(KLiteral.Nat(limbs))),
 
       Expr.App(f, a) =>
         store(KExprNode.App(
-          convert_expr(f, sharing, ref_idxs, recur_idxs, lit_blobs, univs),
-          convert_expr(a, sharing, ref_idxs, recur_idxs, lit_blobs, univs))),
+          convert_expr(f, sharing, refs, recur_addrs, univs),
+          convert_expr(a, sharing, refs, recur_addrs, univs))),
 
       Expr.Lam(ty, body) =>
         store(KExprNode.Lam(
-          convert_expr(ty, sharing, ref_idxs, recur_idxs, lit_blobs, univs),
-          convert_expr(body, sharing, ref_idxs, recur_idxs, lit_blobs, univs))),
+          convert_expr(ty, sharing, refs, recur_addrs, univs),
+          convert_expr(body, sharing, refs, recur_addrs, univs))),
 
       Expr.All(ty, body) =>
         store(KExprNode.Forall(
-          convert_expr(ty, sharing, ref_idxs, recur_idxs, lit_blobs, univs),
-          convert_expr(body, sharing, ref_idxs, recur_idxs, lit_blobs, univs))),
+          convert_expr(ty, sharing, refs, recur_addrs, univs),
+          convert_expr(body, sharing, refs, recur_addrs, univs))),
 
       Expr.Let(_, ty, val, body) =>
         store(KExprNode.Let(
-          convert_expr(ty, sharing, ref_idxs, recur_idxs, lit_blobs, univs),
-          convert_expr(val, sharing, ref_idxs, recur_idxs, lit_blobs, univs),
-          convert_expr(body, sharing, ref_idxs, recur_idxs, lit_blobs, univs))),
+          convert_expr(ty, sharing, refs, recur_addrs, univs),
+          convert_expr(val, sharing, refs, recur_addrs, univs),
+          convert_expr(body, sharing, refs, recur_addrs, univs))),
 
       Expr.Share(idx) =>
         let ListNode.Cons(e, _) = load(list_drop(sharing, flatten_u64(idx)));
-        convert_expr(e, sharing, ref_idxs, recur_idxs, lit_blobs, univs),
+        convert_expr(e, sharing, refs, recur_addrs, univs),
     }
   }
 
   -- ============================================================================
-  -- Recursor rule conversion
+  -- Constant conversion — one KConstantInfo per Ixon Constant.
+  --
+  -- / scope: Defn, Axiom, Quot only. Muts/IPrj/CPrj/RPrj/DPrj
+  -- (inductive/recursor/projection) added here.2.
   -- ============================================================================
-
-  -- Convert Ixon List‹RecursorRule› to List‹KRecRule›.
-  -- rule_ctor_idxs provides the kernel constant index for each rule's constructor.
-  fn convert_rules(
-    rules: List‹RecursorRule›,
-    rule_ctor_idxs: List‹G›,
-    ctx: ConvertCtx
-  ) -> List‹KRecRule› {
-    match load(rules) {
-      ListNode.Nil => store(ListNode.Nil),
-      ListNode.Cons(rule, rest_rules) =>
-        match rule {
-          RecursorRule.Mk(nfields, rhs) =>
-            match load(rule_ctor_idxs) {
-              ListNode.Cons(ctor_idx, rest_ctor_idxs) =>
-                match ctx {
-                  ConvertCtx.Mk(sharing, ref_idxs, recur_idxs, lit_blobs, univs) =>
-                    let krhs = convert_expr(rhs, sharing, ref_idxs, recur_idxs, lit_blobs, univs);
-                    let krule = KRecRule.Mk(ctor_idx, flatten_u64(nfields), krhs);
-                    store(ListNode.Cons(
-                      krule,
-                      convert_rules(rest_rules, rest_ctor_idxs, ctx))),
-                },
-            },
+  fn convert_definition(d: Definition, sharing: List‹&Expr›,
+                            refs: List‹Addr›, recur_addrs: List‹Addr›,
+                            univs: List‹&Univ›, hint: G) -> KConstantInfo {
+    match d {
+      Definition.Mk(kind, safety, lvls, typ, value) =>
+        let ktyp = convert_expr(typ, sharing, refs, recur_addrs, univs);
+        let kval = convert_expr(value, sharing, refs, recur_addrs, univs);
+        let nlvls = flatten_u64(lvls);
+        match kind {
+          DefKind.Definition =>
+            KConstantInfo.Defn(nlvls, ktyp, kval, safety, hint),
+          DefKind.Opaque =>
+            let is_unsafe = match safety { DefinitionSafety.Unsafe => 1, _ => 0, };
+            KConstantInfo.Opaque(nlvls, ktyp, kval, is_unsafe),
+          DefKind.Theorem =>
+            KConstantInfo.Thm(nlvls, ktyp, kval),
         },
     }
   }
 
-  -- ============================================================================
-  -- Per-kind conversion
-  -- ============================================================================
-
-  fn convert_definition(d: Definition, ctx: ConvertCtx, hint: G) -> KConstantInfo {
-    match ctx {
-      ConvertCtx.Mk(sharing, ref_idxs, recur_idxs, lit_blobs, univs) =>
-        match d {
-          Definition.Mk(kind, safety, lvls, typ, value) =>
-            let ktyp = convert_expr(typ, sharing, ref_idxs, recur_idxs, lit_blobs, univs);
-            let kval = convert_expr(value, sharing, ref_idxs, recur_idxs, lit_blobs, univs);
-            match kind {
-              DefKind.Definition =>
-                KConstantInfo.Defn(flatten_u64(lvls), ktyp, kval, safety, hint),
-              DefKind.Opaque =>
-                match safety {
-                  DefinitionSafety.Unsafe =>
-                    KConstantInfo.Opaque(flatten_u64(lvls), ktyp, kval, 1),
-                  _ =>
-                    KConstantInfo.Opaque(flatten_u64(lvls), ktyp, kval, 0),
-                },
-              DefKind.Theorem =>
-                KConstantInfo.Thm(flatten_u64(lvls), ktyp, kval),
-            },
-        },
+  fn convert_axiom(a: Axiom, sharing: List‹&Expr›,
+                       refs: List‹Addr›, recur_addrs: List‹Addr›,
+                       univs: List‹&Univ›) -> KConstantInfo {
+    match a {
+      Axiom.Mk(is_unsafe, lvls, typ) =>
+        let ktyp = convert_expr(typ, sharing, refs, recur_addrs, univs);
+        KConstantInfo.Axiom(flatten_u64(lvls), ktyp, is_unsafe),
     }
   }
 
-  fn convert_axiom(a: Axiom, ctx: ConvertCtx) -> KConstantInfo {
-    match ctx {
-      ConvertCtx.Mk(sharing, ref_idxs, recur_idxs, lit_blobs, univs) =>
-        match a {
-          Axiom.Mk(is_unsafe, lvls, typ) =>
-            let ktyp = convert_expr(typ, sharing, ref_idxs, recur_idxs, lit_blobs, univs);
-            KConstantInfo.Axiom(flatten_u64(lvls), ktyp, is_unsafe),
-        },
+  fn convert_quotient(q: Quotient, sharing: List‹&Expr›,
+                          refs: List‹Addr›, recur_addrs: List‹Addr›,
+                          univs: List‹&Univ›) -> KConstantInfo {
+    match q {
+      Quotient.Mk(kind, lvls, typ) =>
+        let ktyp = convert_expr(typ, sharing, refs, recur_addrs, univs);
+        KConstantInfo.Quot(flatten_u64(lvls), ktyp, kind),
     }
   }
 
-  fn convert_quotient(q: Quotient, ctx: ConvertCtx) -> KConstantInfo {
-    match ctx {
-      ConvertCtx.Mk(sharing, ref_idxs, recur_idxs, lit_blobs, univs) =>
-        match q {
-          Quotient.Mk(kind, lvls, typ) =>
-            let ktyp = convert_expr(typ, sharing, ref_idxs, recur_idxs, lit_blobs, univs);
-            KConstantInfo.Quot(flatten_u64(lvls), ktyp, kind),
-        },
+  -- Count ctors in Inductive.ctors list.
+  fn count_ctors(cs: List‹Constructor›) -> G {
+    match load(cs) {
+      ListNode.Nil => 0,
+      ListNode.Cons(_, rest) => count_ctors(rest) + 1,
     }
   }
 
-  fn convert_recursor(r: Recursor, ctx: ConvertCtx, rule_ctor_idxs: List‹G›,
-                      block_addr: Addr) -> KConstantInfo {
-    match ctx {
-      ConvertCtx.Mk(sharing, ref_idxs, recur_idxs, lit_blobs, univs) =>
-        match r {
-          Recursor.Mk(k, is_unsafe, lvls, params, indices, motives, minors, typ, rules) =>
-            let ktyp = convert_expr(typ, sharing, ref_idxs, recur_idxs, lit_blobs, univs);
-            let krules = convert_rules(rules, rule_ctor_idxs, ctx);
-            KConstantInfo.Rec(
-              flatten_u64(lvls), ktyp, flatten_u64(params), flatten_u64(indices),
-              flatten_u64(motives), flatten_u64(minors),
-              krules, k, is_unsafe, block_addr),
+  -- Look up Constructor at cidx in Inductive.ctors.
+  fn ctor_at(cs: List‹Constructor›, cidx: G) -> Constructor {
+    match load(cs) {
+      ListNode.Cons(c, rest) =>
+        match cidx {
+          0 => c,
+          _ => ctor_at(rest, cidx - 1),
         },
     }
   }
 
-  fn convert_inductive(ind: Inductive, ctx: ConvertCtx, ctor_idxs: List‹G›,
-                       block_addr: Addr) -> KConstantInfo {
-    match ctx {
-      ConvertCtx.Mk(sharing, ref_idxs, recur_idxs, lit_blobs, univs) =>
-        match ind {
-          Inductive.Mk(is_unsafe, lvls, params, indices, typ, _) =>
-            let ktyp = convert_expr(typ, sharing, ref_idxs, recur_idxs, lit_blobs, univs);
-            KConstantInfo.Induct(
-              flatten_u64(lvls), ktyp, flatten_u64(params), flatten_u64(indices),
-              ctor_idxs, is_unsafe, block_addr),
-        },
+  fn convert_inductive(ind: Inductive, block_addr: Addr, ind_idx: G,
+                           sharing: List‹&Expr›, refs: List‹Addr›,
+                           recur_addrs: List‹Addr›,
+                           univs: List‹&Univ›) -> KConstantInfo {
+    match ind {
+      Inductive.Mk(is_unsafe, lvls, params, indices, typ, ctors) =>
+        let ktyp = convert_expr(typ, sharing, refs, recur_addrs, univs);
+        KConstantInfo.Induct(
+          flatten_u64(lvls), ktyp,
+          flatten_u64(params), flatten_u64(indices),
+          count_ctors(ctors), is_unsafe,
+          block_addr, ind_idx),
     }
   }
 
-  fn convert_constructor(c: Constructor, ctx: ConvertCtx, induct_idx: G) -> KConstantInfo {
-    match ctx {
-      ConvertCtx.Mk(sharing, ref_idxs, recur_idxs, lit_blobs, univs) =>
-        match c {
-          Constructor.Mk(is_unsafe, lvls, cidx, params, fields, typ) =>
-            let ktyp = convert_expr(typ, sharing, ref_idxs, recur_idxs, lit_blobs, univs);
-            KConstantInfo.Ctor(
-              flatten_u64(lvls), ktyp, induct_idx, flatten_u64(cidx),
-              flatten_u64(params), flatten_u64(fields), is_unsafe),
-        },
+  fn convert_constructor(c: Constructor, block_addr: Addr, ind_idx: G,
+                             sharing: List‹&Expr›, refs: List‹Addr›,
+                             recur_addrs: List‹Addr›,
+                             univs: List‹&Univ›) -> KConstantInfo {
+    match c {
+      Constructor.Mk(is_unsafe, lvls, cidx, params, fields, typ) =>
+        let ktyp = convert_expr(typ, sharing, refs, recur_addrs, univs);
+        KConstantInfo.Ctor(
+          flatten_u64(lvls), ktyp,
+          block_addr, ind_idx, flatten_u64(cidx),
+          flatten_u64(params), flatten_u64(fields), is_unsafe),
     }
   }
 
-  -- ============================================================================
-  -- Top-level conversion
-  -- ============================================================================
-
-  -- Convert a single resolved input to a KConstantInfo. Takes &ConvertInput
-  -- (pointer) so the per-row input width is one G column, not the full
-  -- ConvertInput union width.
-  fn convert_one(input: &ConvertInput) -> KConstantInfo {
-    match load(input) {
-      ConvertInput.Mk(ctx, kind) =>
-        match kind {
-          ConvertKind.CKDefn(d, hint) => convert_definition(d, ctx, hint),
-          ConvertKind.CKAxio(a) => convert_axiom(a, ctx),
-          ConvertKind.CKQuot(q) => convert_quotient(q, ctx),
-          ConvertKind.CKRecr(r, rule_ctor_idxs, block_addr) =>
-            convert_recursor(r, ctx, rule_ctor_idxs, block_addr),
-          ConvertKind.CKIndc(ind, ctor_idxs, block_addr) => convert_inductive(ind, ctx, ctor_idxs, block_addr),
-          ConvertKind.CKCtor(c, induct_idx) => convert_constructor(c, ctx, induct_idx),
+  fn convert_rec_rules(rs: List‹RecursorRule›, sharing: List‹&Expr›,
+                           refs: List‹Addr›, recur_addrs: List‹Addr›,
+                           univs: List‹&Univ›, cidx: G) -> List‹KRecRule› {
+    match load(rs) {
+      ListNode.Nil =>
+        store(ListNode.Nil),
+      ListNode.Cons(r, rest) =>
+        match r {
+          RecursorRule.Mk(fields, rhs) =>
+            let krhs = convert_expr(rhs, sharing, refs, recur_addrs, univs);
+            store(ListNode.Cons(
+              KRecRule.Mk(cidx, flatten_u64(fields), krhs),
+              convert_rec_rules(rest, sharing, refs, recur_addrs, univs, cidx + 1))),
         },
     }
   }
 
-  -- Convert a list of resolved inputs to a List‹&KConstantInfo›
-  fn convert_all(inputs: List‹&ConvertInput›) -> List‹&KConstantInfo› {
-    match load(inputs) {
-      ListNode.Nil => store(ListNode.Nil),
-      ListNode.Cons(input, rest) =>
-        let ci = convert_one(input);
-        store(ListNode.Cons(store(ci), convert_all(rest))),
+  fn convert_recursor(r: Recursor, block_addr: Addr, rec_idx: G,
+                          sharing: List‹&Expr›, refs: List‹Addr›,
+                          recur_addrs: List‹Addr›,
+                          univs: List‹&Univ›) -> KConstantInfo {
+    match r {
+      Recursor.Mk(k, is_unsafe, lvls, params, indices, motives, minors, typ, rules) =>
+        let ktyp = convert_expr(typ, sharing, refs, recur_addrs, univs);
+        let krules = convert_rec_rules(rules, sharing, refs, recur_addrs, univs, 0);
+        KConstantInfo.Rec(
+          flatten_u64(lvls), ktyp,
+          flatten_u64(params), flatten_u64(indices),
+          flatten_u64(motives), flatten_u64(minors),
+          krules, k, is_unsafe,
+          block_addr, rec_idx),
     }
   }
 ⟧
diff --git a/Ix/IxVM/Core.lean b/Ix/IxVM/Core.lean
index 1cca6251c..a32e74d71 100644
--- a/Ix/IxVM/Core.lean
+++ b/Ix/IxVM/Core.lean
@@ -18,11 +18,127 @@ def core := ⟦
     None
   }
 
-  -- Interned 32-element address (blake3 content hash). Aiur `store`
-  -- content-dedups structurally-equal arrays to one canonical pointer,
-  -- so address equality reduces to pointer subtraction.
+  -- Interned 32-element address (blake3 content hash).
+  --
+  -- DIFFERENT POINTER VALUES DO NOT IMPLY DIFFERENT DATA. The Aiur
+  -- executor content-dedups `store`, so in an honest trace equal content
+  -- yields one canonical pointer — but that is an executor convention,
+  -- not a constraint. The memory AIR (`crates/aiur/src/memory.rs`)
+  -- enforces only that `is_real` is boolean, that real rows form a
+  -- prefix, and that `ptr + 1 = ptr_next`. Pointers are unique; VALUES
+  -- ARE NOT. `Op::Store` witnesses its pointer as a free auxiliary column
+  -- and merely requires `(channel, size, ptr, values)` to be present in
+  -- the memory table, so a prover may commit two rows holding identical
+  -- content and direct a store to either.
+  --
+  -- Consequently, comparing addresses is `address_eq` — NEVER a pointer
+  -- subtraction. A raw `ptr_val` comparison is admissible in exactly two
+  -- places, and both must say so at the site:
+  --   1. as a fast path with a COMPLETE fallback that decides correctly
+  --      when the pointers differ (`level_struct_eq`, `ind_is_solo`,
+  --      `canon_cmp_kexpr_ctx`, the `k_is_def_eq` entry shortcut), or
+  --   2. inside `assert_eq!`, where only the positive answer is acted on
+  --      and a spurious mismatch costs completeness, never soundness.
   type Addr = &[U8; 32]
 
+  -- Cold path of `address_eq`: byte 0 already matched, compare the other
+  -- 31. A separate function on purpose — Aiur charges a function's full
+  -- width on every one of its rows, so a nested match inside `address_eq`
+  -- would save nothing; the split has to be a function boundary, and this
+  -- circuit's height is only the rare byte-0-match rows.
+  fn address_eq_tail(a: Addr, b: Addr) -> G {
+    let [_, a1, a2, a3, a4, a5, a6, a7,
+         a8, a9, a10, a11, a12, a13, a14, a15,
+         a16, a17, a18, a19, a20, a21, a22, a23,
+         a24, a25, a26, a27, a28, a29, a30, a31] = load(a);
+    let [_, b1, b2, b3, b4, b5, b6, b7,
+         b8, b9, b10, b11, b12, b13, b14, b15,
+         b16, b17, b18, b19, b20, b21, b22, b23,
+         b24, b25, b26, b27, b28, b29, b30, b31] = load(b);
+    -- Pack 7 bytes per field element, base 256, then compare packed
+    -- limbs: 31 matched variables become 5. A `U8` is `< 256` by type, so
+    -- base-256 packing is INJECTIVE and the comparison decides byte
+    -- equality exactly — unlike a weighted sum with smaller coefficients,
+    -- where distinct byte strings collide and unequal addresses would
+    -- compare equal. Seven is the largest safe group: `256^7 - 1 = 2^56-1`
+    -- fits Goldilocks, while eight bytes would reach `2^64-1 > p` and wrap
+    -- the packing back into collisions.
+    -- Compared one limb at a time, each packed inside the branch that
+    -- needs it: a mismatch in an early group returns without ever packing
+    -- the later ones. Width is set by the widest path, so this costs the
+    -- same as comparing all five at once and executes strictly less.
+    let pa1 = ((((((to_field(a7) * 256) + to_field(a6)) * 256 +
+                 to_field(a5)) * 256 + to_field(a4)) * 256 +
+                 to_field(a3)) * 256 + to_field(a2)) * 256 + to_field(a1);
+    let pb1 = ((((((to_field(b7) * 256) + to_field(b6)) * 256 +
+                 to_field(b5)) * 256 + to_field(b4)) * 256 +
+                 to_field(b3)) * 256 + to_field(b2)) * 256 + to_field(b1);
+    match pa1 - pb1 {
+      0 =>
+        let pa2 = ((((((to_field(a14) * 256) + to_field(a13)) * 256 +
+                     to_field(a12)) * 256 + to_field(a11)) * 256 +
+                     to_field(a10)) * 256 + to_field(a9)) * 256 + to_field(a8);
+        let pb2 = ((((((to_field(b14) * 256) + to_field(b13)) * 256 +
+                     to_field(b12)) * 256 + to_field(b11)) * 256 +
+                     to_field(b10)) * 256 + to_field(b9)) * 256 + to_field(b8);
+        match pa2 - pb2 {
+          0 =>
+            let pa3 = ((((((to_field(a21) * 256) + to_field(a20)) * 256 +
+                         to_field(a19)) * 256 + to_field(a18)) * 256 +
+                         to_field(a17)) * 256 + to_field(a16)) * 256 +
+                         to_field(a15);
+            let pb3 = ((((((to_field(b21) * 256) + to_field(b20)) * 256 +
+                         to_field(b19)) * 256 + to_field(b18)) * 256 +
+                         to_field(b17)) * 256 + to_field(b16)) * 256 +
+                         to_field(b15);
+            match pa3 - pb3 {
+              0 =>
+                let pa4 = ((((((to_field(a28) * 256) + to_field(a27)) * 256 +
+                             to_field(a26)) * 256 + to_field(a25)) * 256 +
+                             to_field(a24)) * 256 + to_field(a23)) * 256 +
+                             to_field(a22);
+                let pb4 = ((((((to_field(b28) * 256) + to_field(b27)) * 256 +
+                             to_field(b26)) * 256 + to_field(b25)) * 256 +
+                             to_field(b24)) * 256 + to_field(b23)) * 256 +
+                             to_field(b22);
+                match pa4 - pb4 {
+                  0 =>
+                    let pa5 = ((to_field(a31) * 256) + to_field(a30)) * 256 +
+                                to_field(a29);
+                    let pb5 = ((to_field(b31) * 256) + to_field(b30)) * 256 +
+                                to_field(b29);
+                    match pa5 - pb5 {
+                      0 => 1,
+                      _ => 0,
+                    },
+                  _ => 0,
+                },
+              _ => 0,
+            },
+          _ => 0,
+        },
+      _ => 0,
+    }
+  }
+
+  -- Content equality over all 32 bytes. Sound in BOTH directions, and
+  -- therefore the only comparison that may decide anything about two
+  -- addresses.
+  --
+  -- Byte-0 prefilter: one differing byte proves inequality, and nearly
+  -- every comparison — the primitive-dispatch gauntlet in whnf above all
+  -- — mismatches at byte 0, so hot rows reject at narrow width and only
+  -- byte-0 matches pay the wide tail. Result is identical to a flat
+  -- 32-byte compare.
+  fn address_eq(a: Addr, b: Addr) -> G {
+    let av = load(a);
+    let bv = load(b);
+    match to_field(av[0]) - to_field(bv[0]) {
+      0 => address_eq_tail(a, b),
+      _ => 0,
+    }
+  }
+
   fn list_length‹T›(list: List‹T›) -> G {
     match load(list) {
       ListNode.Nil => 0,
@@ -56,6 +172,13 @@ def core := ⟦
     v
   }
 
+  fn list_lookup_or_default‹T›(list: List‹T›, idx: G, default: T) -> T {
+    match load(list_drop(list, idx)) {
+      ListNode.Nil => default,
+      ListNode.Cons(v, _) => v,
+    }
+  }
+
   fn list_lookup_u64‹T›(list: List‹T›, idx: U64) -> T {
     let ListNode.Cons(v, rest) = load(list);
     let z = u64_is_zero(idx);
diff --git a/Ix/IxVM/Ingress.lean b/Ix/IxVM/Ingress.lean
index 629b7ff0b..47e7c3e40 100644
--- a/Ix/IxVM/Ingress.lean
+++ b/Ix/IxVM/Ingress.lean
@@ -1,128 +1,56 @@
 module
-import Ix.Aiur.Meta
-public import Ix.Aiur.Stages.Source
+public import Ix.Aiur.Meta
 
 public section
 
 namespace IxVM
 
 def ingress := ⟦
-  -- IOBuffer channel identifiers. See `ClaimHarness.lean` for the host-side
-  -- counterpart that seeds these channels.
   -- ============================================================================
-  -- IxVM IOBuffer interface
+  -- Ingress — lazy fault-loading get_ci + IOBuffer channel wiring
   --
-  -- The host (Lean `IxVM.ClaimHarness`) seeds blake3-keyed payloads on six
-  -- channels; the kernel consumes them via `io_get_info` + `#read_byte_stream`.
-  -- One value shape per channel — no overloading, no in-band discriminators.
+  -- Channels. Host side is `IxVM.ClaimHarness.addEntries`; that module's
+  -- "IxVM IOBuffer interface" section is the normative table and these
+  -- literals must stay in sync with it.
   --
-  -- Tiered by access pattern (matches kernel runtime order):
+  --   ch 0  claim wire bytes        key = blake3(claim_bytes) = claim digest
+  --   ch 1  assumption tree bytes   key = tree.root
+  --   ch 2  constant wire bytes     key = constant addr
+  --   ch 3  Defn reducibility hint  key = defn addr
+  --   ch 4  blob raw bytes          key = blob addr
   --
-  --   Tier 1 — control input (one-per-run):
-  --     ch 0  claim wire bytes        key = blake3(claim_bytes)        value = claim bytes
-  --     ch 1  assumption tree bytes   key = tree.root                  value = tree bytes
+  -- One value shape per channel, and every key is the content address of
+  -- the value it maps to. An address is seeded on ch 2 iff it is a
+  -- constant and on ch 4 iff it is a blob; the two sets are disjoint.
+  -- ch 0/1/2/4 are BOUND: the kernel re-derives the key from the bytes it
+  -- read and asserts equality, so the host cannot substitute a payload
+  -- (for ch 1 the derivation is a merkle-root recomputation, not a hash of
+  -- the bytes). ch 3 is advisory — it selects a reduction heuristic, and
+  -- def-eq is sound under any value.
   --
-  --   Tier 2 — per-const data:
-  --     ch 2  constant wire bytes     key = const.addr                 value = const bytes
-  --     ch 3  Defn reducibility hint  key = defn.addr                  value = [hint_G]
-  --
-  --   Tier 3 — per-blob data:
-  --     ch 4  blob discriminator      key = addr                       value = [1=const,0=blob]
-  --     ch 5  blob raw bytes          key = blob.addr                  value = raw bytes
-  --
-  -- Soundness: every kernel-consumed byte stream is blake3-verified
-  -- against its key (ch 0/1/2/5). ch 3 hint is semantically optional
-  -- (controls WHNF heuristic only; def-eq is sound either way). ch 4
-  -- discriminator is sound by erasure-correctness: lying flips the
-  -- const/blob decision and the wrong-path load fails downstream.
-  --
-  -- Per-channel access patterns are inlined at each consumer (one site
-  -- per channel) so the dispatch never crosses a fn boundary — channel
-  -- choice doesn't add Aiur per-row width tax. Each `io_get_info` +
-  -- `#read_byte_stream` pair appears once at the producer call site.
-  -- Channel numbers MUST stay in sync with `Ix/IxVM/ClaimHarness.lean`.
+  -- The `idx`/`len` pair returned by `io_get_info` is unconstrained prover
+  -- witness. It is safe solely as a locator for bytes that are then bound —
+  -- a wrong span fails the re-hash. Never branch on it: that hands the
+  -- prover a control-flow decision taken before anything is bound. Callers
+  -- that need to know whether an address is a constant or a blob derive it
+  -- from Expr context (see `blob_idxs_of` in Kernel/Claim.lean), never by
+  -- probing a channel.
   -- ============================================================================
 
-  -- Load a constant from IOBuffer by address (ch 2), verify blake3,
-  -- deserialize.
+  -- Load and blake3-verify Ixon Constant bytes at `addr`.
   fn load_verified_constant(addr: Addr) -> Constant {
     let raw = load(addr);
     let (idx, len) = io_get_info(2, raw);
     let bytes = #read_byte_stream(2, idx, len);
     verify_bytes_against(bytes, raw);
     let (constant, rest) = get_constant(bytes);
-    assert_eq!(load(rest), ListNode.Nil);
+    assert_eq!(load(rest), ListNode.Nil,
+      "trailing bytes after constant on ch 2");
     constant
   }
 
-  -- Load a blob from IOBuffer by address (ch 5), verify blake3, return
-  -- raw bytes.
-  fn load_verified_blob(addr: Addr) -> ByteStream {
-    let raw = load(addr);
-    let (idx, len) = io_get_info(5, raw);
-    let bytes = #read_byte_stream(5, idx, len);
-    verify_bytes_against(bytes, raw);
-    bytes
-  }
-
-  -- Compare two 32-byte addresses for equality.
-  --
-  -- Cold path: limb 0 already matched, compare the remaining 31 limbs.
-  -- Factored into its own function so it forms a separate circuit whose height
-  -- is only the (rare) limb-0-match rows; Aiur charges a function's full width
-  -- on every one of its rows, so a nested match in `address_eq` would not save
-  -- anything — the split must be a function boundary.
-  fn address_eq_tail(a: Addr, b: Addr) -> G {
-    let [_, a1, a2, a3, a4, a5, a6, a7,
-         a8, a9, a10, a11, a12, a13, a14, a15,
-         a16, a17, a18, a19, a20, a21, a22, a23,
-         a24, a25, a26, a27, a28, a29, a30, a31] = load(a);
-    let [_, b1, b2, b3, b4, b5, b6, b7,
-         b8, b9, b10, b11, b12, b13, b14, b15,
-         b16, b17, b18, b19, b20, b21, b22, b23,
-         b24, b25, b26, b27, b28, b29, b30, b31] = load(b);
-    match [to_field(a1) - to_field(b1),
-           to_field(a2) - to_field(b2), to_field(a3) - to_field(b3),
-           to_field(a4) - to_field(b4), to_field(a5) - to_field(b5),
-           to_field(a6) - to_field(b6), to_field(a7) - to_field(b7),
-           to_field(a8) - to_field(b8), to_field(a9) - to_field(b9),
-           to_field(a10) - to_field(b10), to_field(a11) - to_field(b11),
-           to_field(a12) - to_field(b12), to_field(a13) - to_field(b13),
-           to_field(a14) - to_field(b14), to_field(a15) - to_field(b15),
-           to_field(a16) - to_field(b16), to_field(a17) - to_field(b17),
-           to_field(a18) - to_field(b18), to_field(a19) - to_field(b19),
-           to_field(a20) - to_field(b20), to_field(a21) - to_field(b21),
-           to_field(a22) - to_field(b22), to_field(a23) - to_field(b23),
-           to_field(a24) - to_field(b24), to_field(a25) - to_field(b25),
-           to_field(a26) - to_field(b26), to_field(a27) - to_field(b27),
-           to_field(a28) - to_field(b28), to_field(a29) - to_field(b29),
-           to_field(a30) - to_field(b30), to_field(a31) - to_field(b31)] {
-      [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] => 1,
-      _ => 0,
-    }
-  }
-
-  -- Limb-0 prefilter: a single differing limb proves inequality, and almost
-  -- every comparison (the primitive-dispatch gauntlet in whnf) mismatches at
-  -- limb 0. Hot rows reject here at narrow width; only limb-0 matches pay the
-  -- wide `address_eq_tail` compare. Identical result to a full 32-limb compare.
-  fn address_eq(a: Addr, b: Addr) -> G {
-    let av = load(a);
-    let bv = load(b);
-    match to_field(av[0]) - to_field(bv[0]) {
-      0 => address_eq_tail(a, b),
-      _ => 0,
-    }
-  }
-
-  -- Load reducibility hint G for a Defn at `addr` (ch 3). Encoding
-  -- mirrors `Lean.ReducibilityHints`:
-  --   0           = Opaque
-  --   1 + h       = Regular(h)
-  --   0xFFFFFFFF  = Abbrev
-  -- Caller MUST only invoke this for Defn addrs; the harness only
-  -- seeds ch 3 for Defns. A missing key aborts execution (correct).
+  -- Load reducibility hint G for a Defn at `addr` (ch 3).
+  -- Encoding: 0 = Opaque, 1+h = Regular(h), 0xFFFFFFFF = Abbrev.
   fn load_constant_hint(addr: Addr) -> G {
     let raw = load(addr);
     let (idx, len) = io_get_info(3, raw);
@@ -132,1569 +60,301 @@ def ingress := ⟦
     }
   }
 
-  -- Sentinel value stored in `addr_pos_map` for addresses known to be
-  -- blob refs (not constants). Beyond any honest `pos+1` so it cannot
-  -- collide with a real const-position encoding.
-  fn sentinel_blob_ref() -> G { 4294967295 }
-
-  -- Extract the Muts block address from a projection ConstantInfo.
-  -- Returns [0; 32] for non-projection constants.
-  fn get_proj_block_addr(info: ConstantInfo) -> Addr {
-    match info {
-      ConstantInfo.IPrj(prj) =>
-        match prj { InductiveProj.Mk(_, addr) => addr, },
-      ConstantInfo.CPrj(prj) =>
-        match prj { ConstructorProj.Mk(_, _, addr) => addr, },
-      ConstantInfo.RPrj(prj) =>
-        match prj { RecursorProj.Mk(_, addr) => addr, },
-      ConstantInfo.DPrj(prj) =>
-        match prj { DefinitionProj.Mk(_, addr) => addr, },
-      ConstantInfo.Defn(_) => store([0u8; 32]),
-      ConstantInfo.Recr(_) => store([0u8; 32]),
-      ConstantInfo.Axio(_) => store([0u8; 32]),
-      ConstantInfo.Quot(_) => store([0u8; 32]),
-      ConstantInfo.Muts(_) => store([0u8; 32]),
-    }
+  -- Load and blake3-verify blob bytes at `addr` from ch 4.
+  fn load_verified_blob(addr: Addr) -> ByteStream {
+    let raw = load(addr);
+    let (idx, len) = io_get_info(4, raw);
+    let bytes = #read_byte_stream(4, idx, len);
+    verify_bytes_against(bytes, raw);
+    bytes
   }
 
   -- ============================================================================
-  -- Position map: maps loaded addresses to kernel constant positions.
+  -- get_ci: THE constant resolver.
   --
-  -- When a Muts block is encountered, its members are expanded inline into
-  -- kernel constants: each Indc becomes 1 Induct + N Ctors, each Recr becomes
-  -- 1 Rec, each Defn becomes 1 Defn. Projection constants (IPrj, CPrj, RPrj,
-  -- DPrj) are not emitted directly — instead they map to the position of their
-  -- corresponding expanded member.
-  -- ============================================================================
-
-  -- Count the number of kernel entries a single MutConst member produces:
-  -- Indc: 1 (inductive) + num_ctors
-  -- Recr: 1
-  -- Defn: 1
-  fn member_kernel_size(mc: MutConst) -> G {
-    match mc {
-      MutConst.Indc(ind) =>
-        match ind {
-          Inductive.Mk(_, _, _, _, _, ctors) =>
-            list_length(ctors) + 1,
-        },
-      MutConst.Recr(_) => 1,
-      MutConst.Defn(_) => 1,
-    }
-  }
-
-  -- Count total kernel entries for an entire List‹MutConst›
-  fn block_kernel_size(members: List‹MutConst›) -> G {
-    match load(members) {
-      ListNode.Nil => 0,
-      ListNode.Cons(mc, rest) =>
-        member_kernel_size(mc) + block_kernel_size(rest),
-    }
-  }
-
-  -- Compute the offset of member at member_idx within a block's expansion.
-  -- Members before member_idx each contribute member_kernel_size entries.
-  fn member_offset(members: List‹MutConst›, target_idx: G) -> G {
-    match target_idx {
-      0 => 0,
-      _ =>
-        match load(members) {
-          ListNode.Cons(mc, rest) =>
-            member_kernel_size(mc) + member_offset(rest, target_idx - 1),
-        },
-    }
-  }
-
-  -- Resolve an address to its kernel position via `addr_pos_map`:
-  -- SENTINEL (4294967295) → blob ref → 0; else → const at `hit-1`.
-  -- Panic-on-miss `rbtree_map_lookup` asserts presence; see
-  -- `build_addr_pos_map` for why a miss is rejected, not recovered.
-  fn lookup_addr_pos(target: Addr, addr_pos_map: &RBTreeMap‹G›) -> G {
-    let hit = rbtree_map_lookup(ptr_val(target), load(addr_pos_map));
-    match hit {
-      4294967295 => 0,
-      _ => hit - 1,
-    }
-  }
-
-  -- `ptr_val(addr) → pos+1` for every const (`pos+1` keeps 0 free; the blob
-  -- SENTINEL sits above any pos+1). Head inserted last, so duplicate
-  -- `ptr_val`s resolve to the first (canonical) position.
+  -- Faults `addr`'s Ixon Constant from IOBuffer, blake3-verifies,
+  -- deserializes, and converts to KConstantInfo. Aiur memoizes per `addr`
+  -- pointer — each distinct addr resolves at most once per run.
   --
-  -- Soundness: the memory AIR strictly increments the pointer column, so the
-  -- table is a function ptr → values ⟹ `ptr_val` eq ⟹ content eq (no false
-  -- collisions; a hit is always correct). The converse can fail — a malicious
-  -- witness may de-intern (same content at several pointers) — so consumers
-  -- probe with panic-on-miss `rbtree_map_lookup`: a de-intern miss is rejected,
-  -- and honest provers always hit (they intern; every ref/head address is keyed).
-  fn build_addr_pos_map(all_addrs: List‹Addr›, pos_map: List‹G›) -> RBTreeMap‹G› {
-    match load(all_addrs) {
-      ListNode.Nil => RBTreeMap.Nil,
-      ListNode.Cons(addr, rest_addrs) =>
-        match load(pos_map) {
-          ListNode.Cons(pos, rest_pos) =>
-            rbtree_map_insert(ptr_val(addr), pos + 1,
-              build_addr_pos_map(rest_addrs, rest_pos)),
-        },
-    }
-  }
-
--- Walk all constants' `refs`. For every ref whose ptr_val is NOT
-  -- already mapped to a const-position (= a true const-ref), insert it
-  -- with the BLOB sentinel `4294967295`. Result: every ref a const
-  -- carries is classified at build time; `lookup_addr_pos` short-circuits
-  -- O(N) linear scans on blob refs to O(log N) probes.
-  --
-  -- Duplicate refs across consts hit the existing entry on subsequent
-  -- inserts; the probe-before-insert prevents overwriting a const's
-  -- pos+1 entry. The walk is O(R log N) where R = total refs in the
-  -- shard's closure, N = #consts + #unique-blob-refs.
-  fn augment_with_blob_refs(consts: List‹&Constant›, m: RBTreeMap‹G›) -> RBTreeMap‹G› {
-    match load(consts) {
-      ListNode.Nil => m,
-      ListNode.Cons(&c, rest) =>
-        match c {
-          Constant.Mk(_, _, refs, _) =>
-            let m1 = insert_refs_as_blobs(refs, m);
-            augment_with_blob_refs(rest, m1),
-        },
-    }
-  }
-
-  fn insert_refs_as_blobs(refs: List‹Addr›, m: RBTreeMap‹G›) -> RBTreeMap‹G› {
-    match load(refs) {
-      ListNode.Nil => m,
-      ListNode.Cons(addr, rest) =>
-        let key = ptr_val(addr);
-        let hit = rbtree_map_lookup_or_default(key, m, 0);
-        match hit {
-          0 =>
-            -- Not yet registered: classify as blob ref via SENTINEL.
-            insert_refs_as_blobs(rest, rbtree_map_insert(key, sentinel_blob_ref(), m)),
-          _ =>
-            -- Already a const (pos+1) or already a blob (SENTINEL): leave alone.
-            insert_refs_as_blobs(rest, m),
-        },
-    }
-  }
-
--- `ptr_val(block_addr) → block_start` for every Muts block. O(log N) probe
-  -- vs an O(N) parallel-list walk.
-  --
-  -- `lookup_block_start` probes with panic-on-miss `rbtree_map_lookup`. A
-  -- `_or_default 0` would be UNSOUND: starts are raw 0-based, so `0` is a
-  -- valid position (the first block), not an absent-sentinel — a de-interned
-  -- `block_addr` would miss and silently resolve the projection to the wrong
-  -- slot. Honest provers always hit (the block is loaded and keyed; interning
-  -- makes the lookup pointer equal the keyed pointer).
-  fn build_block_start_map(block_addrs: List‹Addr›, block_starts: List‹G›) -> RBTreeMap‹G› {
-    build_block_start_map_walk(block_addrs, block_starts, RBTreeMap.Nil)
-  }
-
-  fn build_block_start_map_walk(block_addrs: List‹Addr›, block_starts: List‹G›,
-                                 acc: RBTreeMap‹G›) -> RBTreeMap‹G› {
-    match load(block_addrs) {
-      ListNode.Nil => acc,
-      ListNode.Cons(addr, rest_addrs) =>
-        match load(block_starts) {
-          ListNode.Cons(start, rest_starts) =>
-            build_block_start_map_walk(rest_addrs, rest_starts,
-              rbtree_map_insert(ptr_val(addr), start, acc)),
-        },
-    }
-  }
-
-  -- Panic-on-miss asserts presence; see `build_block_start_map`.
-  fn lookup_block_start(target: Addr, block_start_map: &RBTreeMap‹G›) -> G {
-    rbtree_map_lookup(ptr_val(target), load(block_start_map))
-  }
-
+  -- / scope: Defn / Axiom / Quot. Projections (IPrj/CPrj/RPrj/DPrj)
+  -- + Muts wrappers arrive here.2 (recursor + inductive support).
   -- ============================================================================
-  -- Layout pass: compute block start positions and total kernel size
-  -- ============================================================================
-
-  -- Returns 1 if `mptr` is in the seen list.
-  fn is_mptr_seen(mptr: G, seen: List‹G›) -> G {
-    match load(seen) {
-      ListNode.Nil => 0,
-      ListNode.Cons(s, rest) =>
-        match s - mptr {
-          0 => 1,
-          _ => is_mptr_seen(mptr, rest),
-        },
-    }
-  }
-
-  -- Singleton-Indc Muts deduplication: structurally-identical singleton-Indc
-  -- Muts wrappers (per-Lean-constant content) collapse to one canonical
-  -- block to avoid emitting duplicate Ctor/Indc entries in `top` whose
-  -- cross-references (induct_idx ↔ ctor_indices) wouldn't be consistent
-  -- across the duplicates. Mirror Rust kernel's content-addressed dedup
-  -- where the same Indc content has one shared kernel position.
-  --
-  -- Multi-member Muts (true mutual blocks) and non-singleton variants are
-  -- not deduped (extract_muts_members_ptr returns 0 for them).
-  fn extract_dedup_mptr(c: Constant) -> G {
-    -- Dedup singleton-Indc Muts wrappers (Lean's per-constant canonical
-    -- encoding). Key = full Constant.Mk ptr — Aiur store dedupes
-    -- structurally identical Constants, so two wrapper aliases for the
-    -- same logical Indc share this ptr. Inner-Indc-only dedup is too
-    -- coarse: IXON canonicalization makes UInt8.Indc and UInt32.Indc
-    -- collide at the Inductive.Mk level (literal width is a blob-ref
-    -- index, not inline), but their wrapper Constants differ via refs.
-    --
-    -- Conservative: still gated on singleton-Indc Muts. Defn/Recr/multi-
-    -- member Muts skip dedup (caller layout handles them positionally).
+  fn get_ci(addr: Addr) -> &KConstantInfo {
+    let c = load_verified_constant(addr);
     match c {
-      Constant.Mk(info, _, _, _) =>
+      Constant.Mk(info, sharing, refs, univs) =>
         match info {
-          ConstantInfo.Muts(members) =>
-            match is_singleton_indc(members) {
-              0 => 0,
-              1 => ptr_val(store(c)),
-            },
-          _ => 0,
-        },
-    }
-  }
-
-  fn is_singleton_indc(members: List‹MutConst›) -> G {
-    match load(members) {
-      ListNode.Cons(m, rest) =>
-        match load(rest) {
-          ListNode.Nil =>
-            match m {
-              MutConst.Indc(_) => 1,
-              _ => 0,
+          ConstantInfo.Defn(defn) =>
+            let hint = #load_constant_hint(addr);
+            -- Standalone Defn: a single recur slot naming ITSELF, and only
+            -- for an unsafe definition.
+            --
+            -- `Rec` converts to a plain `Const`, and `k_infer` reads a
+            -- `Const`'s DECLARED type without checking it. So a self slot
+            -- lets a definition discharge its own type by citing itself:
+            -- `theorem bad : False := bad` would typecheck, since the
+            -- referent is the constant already under check and the
+            -- ref-walk does not follow `Rec`. Lean forbids exactly this by
+            -- checking a definition against an environment that does not
+            -- yet contain it, admitting self-reference only for `unsafe`.
+            --
+            -- `unsafe` and `partial` are where self-reference is both
+            -- legitimate and contained. Legitimate because the compiler
+            -- emits a singleton or fully-collapsed mutual block as a
+            -- standalone `Defn` whose body still says `Rec(0)`, and those
+            -- blocks are exactly Lean's `unsafe`/`partial` recursive
+            -- definitions — a `safe` recursive definition compiles its
+            -- recursion into `.rec` applications instead. Contained
+            -- because safe code may not reference either kind, so a
+            -- self-reference cannot leak into the trusted fragment.
+            --
+            -- A `safe` definition gets an empty list, so its `Rec` aborts
+            -- on the out-of-range lookup. Mutual blocks are unaffected —
+            -- their peer slots come from `build_recur_addrs`.
+            let self_recur = match defn {
+              Definition.Mk(_, safety, _, _, _) =>
+                match safety {
+                  DefinitionSafety.Safe => store(ListNode.Nil),
+                  _ => store(ListNode.Cons(addr, store(ListNode.Nil))),
+                },
+            };
+            store(convert_definition(defn, sharing, refs,
+                                          self_recur, univs, hint)),
+          ConstantInfo.Axio(axio) =>
+            -- Axiom bodies have no Rec refs; empty recur_addrs.
+            store(convert_axiom(axio, sharing, refs,
+                                     store(ListNode.Nil), univs)),
+          ConstantInfo.Quot(quot) =>
+            store(convert_quotient(quot, sharing, refs,
+                                        store(ListNode.Nil), univs)),
+          ConstantInfo.DPrj(prj) =>
+            match prj {
+              DefinitionProj.Mk(idx, block_addr) =>
+                get_ci_dprj(addr, idx, block_addr),
             },
-          _ => 0,
-        },
-      _ => 0,
-    }
-  }
-
-  -- Lookup canonical (first-occurrence) pos for an mptr in parallel
-  -- (seen_mptrs, seen_poses) lists. Returns 0 if not found (caller
-  -- guards via is_mptr_seen first).
-  fn first_pos_for_mptr(mptr: G, seen_mptrs: List‹G›, seen_poses: List‹G›) -> G {
-    match load(seen_mptrs) {
-      ListNode.Nil => 0,
-      ListNode.Cons(s, rest_m) =>
-        match load(seen_poses) {
-          ListNode.Cons(q, rest_p) =>
-            match s - mptr {
-              0 => q,
-              _ => first_pos_for_mptr(mptr, rest_m, rest_p),
+          ConstantInfo.IPrj(prj) =>
+            match prj {
+              InductiveProj.Mk(idx, block_addr) =>
+                get_ci_iprj(block_addr, flatten_u64(idx)),
             },
-        },
-    }
-  }
-
-  fn compute_layout(
-    consts: List‹&Constant›,
-    addrs: List‹Addr›,
-    pos: G
-  ) -> (List‹Addr›, List‹G›, G) {
-    compute_layout_walk(consts, addrs, pos, store(ListNode.Nil), store(ListNode.Nil))
-  }
-
-  fn compute_layout_walk(
-    consts: List‹&Constant›,
-    addrs: List‹Addr›,
-    pos: G,
-    seen_mptrs: List‹G›,
-    seen_poses: List‹G›
-  ) -> (List‹Addr›, List‹G›, G) {
-    match load(consts) {
-      ListNode.Nil => (store(ListNode.Nil), store(ListNode.Nil), pos),
-      ListNode.Cons(&c, rest_consts) =>
-        match load(addrs) {
-          ListNode.Cons(addr, rest_addrs) =>
-            match c {
-              Constant.Mk(info, _, _, _) =>
-                match info {
-                  ConstantInfo.Muts(members) =>
-                    let mptr = extract_dedup_mptr(c);
-                    let dup = match mptr {
-                      0 => 0,
-                      _ => is_mptr_seen(mptr, seen_mptrs),
-                    };
-                    match dup {
-                      1 =>
-                        -- Duplicate Muts (same content, different wrapper addr).
-                        -- Don't advance pos; record this wrapper's addr → first
-                        -- occurrence's pos so refs via Expr.Ref(this_wrapper_addr)
-                        -- and IPrj/CPrj/RPrj/DPrj.block_addr=this_wrapper_addr
-                        -- resolve to canonical pos.
-                        let first_pos = first_pos_for_mptr(mptr, seen_mptrs, seen_poses);
-                        let (ba, bs, next) = compute_layout_walk(rest_consts, rest_addrs, pos, seen_mptrs, seen_poses);
-                        (store(ListNode.Cons(addr, ba)),
-                         store(ListNode.Cons(first_pos, bs)),
-                         next),
-                      0 =>
-                        let size = block_kernel_size(members);
-                        let new_seen_m = match mptr {
-                          0 => seen_mptrs,
-                          _ => store(ListNode.Cons(mptr, seen_mptrs)),
-                        };
-                        let new_seen_p = match mptr {
-                          0 => seen_poses,
-                          _ => store(ListNode.Cons(pos, seen_poses)),
-                        };
-                        let (ba, bs, next) = compute_layout_walk(rest_consts, rest_addrs, pos + size, new_seen_m, new_seen_p);
-                        (store(ListNode.Cons(addr, ba)),
-                         store(ListNode.Cons(pos, bs)),
-                         next),
-                    },
-                  ConstantInfo.IPrj(_) =>
-                    compute_layout_walk(rest_consts, rest_addrs, pos, seen_mptrs, seen_poses),
-                  ConstantInfo.CPrj(_) =>
-                    compute_layout_walk(rest_consts, rest_addrs, pos, seen_mptrs, seen_poses),
-                  ConstantInfo.RPrj(_) =>
-                    compute_layout_walk(rest_consts, rest_addrs, pos, seen_mptrs, seen_poses),
-                  ConstantInfo.DPrj(_) =>
-                    compute_layout_walk(rest_consts, rest_addrs, pos, seen_mptrs, seen_poses),
-                  ConstantInfo.Defn(_) =>
-                    compute_layout_walk(rest_consts, rest_addrs, pos + 1, seen_mptrs, seen_poses),
-                  ConstantInfo.Axio(_) =>
-                    compute_layout_walk(rest_consts, rest_addrs, pos + 1, seen_mptrs, seen_poses),
-                  ConstantInfo.Quot(_) =>
-                    compute_layout_walk(rest_consts, rest_addrs, pos + 1, seen_mptrs, seen_poses),
-                  ConstantInfo.Recr(_) =>
-                    compute_layout_walk(rest_consts, rest_addrs, pos + 1, seen_mptrs, seen_poses),
-                },
+          ConstantInfo.CPrj(prj) =>
+            match prj {
+              ConstructorProj.Mk(idx, cidx, block_addr) =>
+                get_ci_cprj(block_addr, flatten_u64(idx), flatten_u64(cidx)),
             },
-        },
-    }
-  }
-
-  -- ============================================================================
-  -- Position map pass: build a List‹G› parallel to all_addrs
-  -- ============================================================================
-
-  fn build_pos_map(
-    consts: List‹&Constant›,
-    addrs: List‹Addr›,
-    block_start_map: &RBTreeMap‹G›,
-    pos: G
-  ) -> List‹G› {
-    build_pos_map_walk(consts, addrs, block_start_map, pos,
-                       store(ListNode.Nil), store(ListNode.Nil))
-  }
-
-  fn build_pos_map_walk(
-    consts: List‹&Constant›,
-    addrs: List‹Addr›,
-    block_start_map: &RBTreeMap‹G›,
-    pos: G,
-    seen_mptrs: List‹G›,
-    seen_poses: List‹G›
-  ) -> List‹G› {
-    match load(consts) {
-      ListNode.Nil => store(ListNode.Nil),
-      ListNode.Cons(&c, rest_consts) =>
-        match load(addrs) {
-          ListNode.Cons(_, rest_addrs) =>
-            match c {
-              Constant.Mk(info, _, _, _) =>
-                match info {
-                  ConstantInfo.Muts(members) =>
-                    let mptr = extract_dedup_mptr(c);
-                    let dup = match mptr {
-                      0 => 0,
-                      _ => is_mptr_seen(mptr, seen_mptrs),
-                    };
-                    match dup {
-                      1 =>
-                        let first_pos = first_pos_for_mptr(mptr, seen_mptrs, seen_poses);
-                        store(ListNode.Cons(first_pos,
-                          build_pos_map_walk(rest_consts, rest_addrs, block_start_map, pos, seen_mptrs, seen_poses))),
-                      0 =>
-                        let size = block_kernel_size(members);
-                        let new_seen_m = match mptr {
-                          0 => seen_mptrs,
-                          _ => store(ListNode.Cons(mptr, seen_mptrs)),
-                        };
-                        let new_seen_p = match mptr {
-                          0 => seen_poses,
-                          _ => store(ListNode.Cons(pos, seen_poses)),
-                        };
-                        store(ListNode.Cons(pos,
-                          build_pos_map_walk(rest_consts, rest_addrs, block_start_map, pos + size, new_seen_m, new_seen_p))),
-                    },
-                  ConstantInfo.IPrj(prj) =>
-                    match prj {
-                      InductiveProj.Mk(idx, block_addr) =>
-                        let block_start = lookup_block_start(block_addr, block_start_map);
-                        let block_const = load_verified_constant(block_addr);
-                        match block_const {
-                          Constant.Mk(block_info, _, _, _) =>
-                            match block_info {
-                              ConstantInfo.Muts(members) =>
-                                let off = member_offset(members, flatten_u64(idx));
-                                store(ListNode.Cons(block_start + off,
-                                  build_pos_map_walk(rest_consts, rest_addrs, block_start_map, pos, seen_mptrs, seen_poses))),
-                            },
-                        },
-                    },
-                  ConstantInfo.CPrj(prj) =>
-                    match prj {
-                      ConstructorProj.Mk(idx, cidx, block_addr) =>
-                        let block_start = lookup_block_start(block_addr, block_start_map);
-                        let block_const = load_verified_constant(block_addr);
-                        match block_const {
-                          Constant.Mk(block_info, _, _, _) =>
-                            match block_info {
-                              ConstantInfo.Muts(members) =>
-                                let mem_off = member_offset(members, flatten_u64(idx));
-                                store(ListNode.Cons(block_start + mem_off + 1 + flatten_u64(cidx),
-                                  build_pos_map_walk(rest_consts, rest_addrs, block_start_map, pos, seen_mptrs, seen_poses))),
-                            },
-                        },
-                    },
-                  ConstantInfo.RPrj(prj) =>
-                    match prj {
-                      RecursorProj.Mk(idx, block_addr) =>
-                        let block_start = lookup_block_start(block_addr, block_start_map);
-                        let block_const = load_verified_constant(block_addr);
-                        match block_const {
-                          Constant.Mk(block_info, _, _, _) =>
-                            match block_info {
-                              ConstantInfo.Muts(members) =>
-                                let off = member_offset(members, flatten_u64(idx));
-                                store(ListNode.Cons(block_start + off,
-                                  build_pos_map_walk(rest_consts, rest_addrs, block_start_map, pos, seen_mptrs, seen_poses))),
-                            },
-                        },
-                    },
-                  ConstantInfo.DPrj(prj) =>
-                    match prj {
-                      DefinitionProj.Mk(idx, block_addr) =>
-                        let block_start = lookup_block_start(block_addr, block_start_map);
-                        let block_const = load_verified_constant(block_addr);
-                        match block_const {
-                          Constant.Mk(block_info, _, _, _) =>
-                            match block_info {
-                              ConstantInfo.Muts(members) =>
-                                let off = member_offset(members, flatten_u64(idx));
-                                store(ListNode.Cons(block_start + off,
-                                  build_pos_map_walk(rest_consts, rest_addrs, block_start_map, pos, seen_mptrs, seen_poses))),
-                            },
-                        },
-                    },
-                  _ =>
-                    store(ListNode.Cons(pos,
-                      build_pos_map_walk(rest_consts, rest_addrs, block_start_map, pos + 1, seen_mptrs, seen_poses))),
-                },
+          ConstantInfo.RPrj(prj) =>
+            match prj {
+              RecursorProj.Mk(idx, block_addr) =>
+                get_ci_rprj(block_addr, flatten_u64(idx)),
             },
+          ConstantInfo.Muts(members) =>
+            -- Muts wrapper referenced directly: return the FIRST member's
+            -- KCI. Rare — usually consumers reference via projections.
+            get_ci_muts_member(addr, members, 0),
+          ConstantInfo.Recr(recr) =>
+            -- Standalone Recr: single recur slot = self.
+            let self_recur = store(ListNode.Cons(addr, store(ListNode.Nil)));
+            store(convert_recursor(recr, addr, 0,
+                                        sharing, refs, self_recur, univs)),
         },
     }
   }
 
-  -- ============================================================================
-  -- Ref index building using position map
-  -- ============================================================================
-
-  -- Fused walk of `refs` → (ref_idxs, lit_blobs), one `addr_pos_map` probe
-  -- per ref: SENTINEL → blob (load+decode, idx 0); else → const at `hit-1`.
-  -- Panic-on-miss `rbtree_map_lookup` is safe: `augment_with_blob_refs` keyed
-  -- every ref from these same list cells, so the probe always hits.
-  fn build_ref_idxs_and_blobs(refs: List‹Addr›, addr_pos_map: &RBTreeMap‹G›)
-                               -> (List‹G›, List‹ByteStream›) {
-    match load(refs) {
-      ListNode.Nil => (store(ListNode.Nil), store(ListNode.Nil)),
-      ListNode.Cons(addr, rest) =>
-        let (rest_idxs, rest_blobs) =
-          build_ref_idxs_and_blobs(rest, addr_pos_map);
-        let hit = rbtree_map_lookup(ptr_val(addr), load(addr_pos_map));
-        match hit {
-          4294967295 =>
-            let bs = load_verified_blob(addr);
-            (store(ListNode.Cons(0, rest_idxs)),
-             store(ListNode.Cons(bs, rest_blobs))),
-          _ =>
-            (store(ListNode.Cons(hit - 1, rest_idxs)),
-             store(ListNode.Cons(store(ListNode.Nil), rest_blobs))),
-        },
-    }
-  }
-
-  -- Mirror of Rust kernel canonicalization (`ingress_compiled_names` /
-  -- `resolve_all`): IXON can encode the same logical inductive via multiple
-  -- wrapper addresses (singleton-Muts vs IPrj-rewrapping vs bundle-Muts).
-  -- Aiur expands each wrapper into its own positional slots, so the same
-  -- inductive lands at distinct kernel positions; refs traveling different
-  -- IXON paths land on different positions and break the `Proj` / `Const`
-  -- identity invariants assumed by infer / def_eq.
-  --
-  -- Dedup key: the `members` `List<MutConst>` Ptr. Aiur `store` content-
-  -- dedupes structurally identical lists, so two Muts wrappers with the
-  -- same member content (e.g. `[Indc(Nat)]`) share a Ptr regardless of the
-  -- outer Constant.Mk wrapper's refs / sharing / univs differences.
-  fn extract_muts_members_ptr(c: &Constant) -> G {
-    -- Same dedup semantic as extract_dedup_mptr: singleton-Indc Muts only,
-    -- keyed on full Constant ptr (so wrappers around different logical
-    -- Indcs that happen to share IXON-canonical Indc.Mk content stay
-    -- distinct via differing refs).
-    match load(c) {
-      Constant.Mk(info, _, _, _) =>
+  -- DPrj resolver: Defn projection.
+  fn get_ci_dprj(dprj_addr: Addr, idx: U64, block_addr: Addr) -> &KConstantInfo {
+    let block_c = load_verified_constant(block_addr);
+    match block_c {
+      Constant.Mk(info, sharing, refs, univs) =>
         match info {
           ConstantInfo.Muts(members) =>
-            match is_singleton_indc(members) {
-              0 => 0,
-              1 => ptr_val(c),
-            },
-          _ => 0,
-        },
-    }
-  }
-
-  fn find_canon_pos_for_mptr(mptr: G, seen_mptrs: List‹G›,
-                              seen_poses: List‹G›, default_pos: G) -> G {
-    match load(seen_mptrs) {
-      ListNode.Nil => default_pos,
-      ListNode.Cons(s, rest_m) =>
-        match load(seen_poses) {
-          ListNode.Cons(q, rest_q) =>
-            match s - mptr {
-              0 => q,
-              _ => find_canon_pos_for_mptr(mptr, rest_m, rest_q, default_pos),
-            },
-        },
-    }
-  }
-
-  fn canonicalize_pos_map_walk(consts: List‹&Constant›, pos_map: List‹G›,
-                                seen_mptrs: List‹G›, seen_poses: List‹G›) -> List‹G› {
-    match load(consts) {
-      ListNode.Nil => store(ListNode.Nil),
-      ListNode.Cons(c, rest_c) =>
-        match load(pos_map) {
-          ListNode.Cons(p, rest_p) =>
-            let mptr = extract_muts_members_ptr(c);
-            let canon_pos = match mptr {
-              0 => p,
-              _ => find_canon_pos_for_mptr(mptr, seen_mptrs, seen_poses, p),
-            };
-            let new_seen_mptrs = match mptr {
-              0 => seen_mptrs,
-              _ => store(ListNode.Cons(mptr, seen_mptrs)),
-            };
-            let new_seen_poses = match mptr {
-              0 => seen_poses,
-              _ => store(ListNode.Cons(canon_pos, seen_poses)),
-            };
-            store(ListNode.Cons(canon_pos,
-              canonicalize_pos_map_walk(rest_c, rest_p, new_seen_mptrs, new_seen_poses))),
-        },
-    }
-  }
-
-  fn canonicalize_pos_map(consts: List‹&Constant›, pos_map: List‹G›) -> List‹G› {
-    canonicalize_pos_map_walk(consts, pos_map, store(ListNode.Nil), store(ListNode.Nil))
-  }
-
-  -- Companion to `canonicalize_pos_map`: produces a `canonical_addr_map`
-  -- parallel to `all_addrs`. Each entry records the FIRST address that
-  -- yielded this Muts content. Used to canonicalize `block_addr` fields
-  -- baked into Inductives by Aiur's positional convert step (without
-  -- this, two distinct wrapper addrs produce Inductives with structurally
-  -- different 10th fields — defeating store-Ptr equality).
-  fn find_canon_addr_for_mptr(mptr: G, seen_mptrs: List‹G›,
-                               seen_addrs: List‹Addr›,
-                               default_addr: Addr) -> Addr {
-    match load(seen_mptrs) {
-      ListNode.Nil => default_addr,
-      ListNode.Cons(s, rest_m) =>
-        match load(seen_addrs) {
-          ListNode.Cons(a, rest_a) =>
-            match s - mptr {
-              0 => a,
-              _ => find_canon_addr_for_mptr(mptr, rest_m, rest_a, default_addr),
-            },
-        },
-    }
-  }
-
-  -- Produce an `Addr → canon_Addr` rbtree keyed by `ptr_val(addr)`. Only
-  -- members of a Muts wrapper that dedupes to an earlier canonical addr
-  -- contribute non-trivial entries; non-Muts and primary-wrapper consts
-  -- map to themselves (and we skip those — `lookup_canon_addr` falls back
-  -- to the target unchanged on miss).
-  --
-  -- ptr_val keying is sound because Aiur Store content-addresses every
-  -- pointer: a positive ptr_val match implies content equality. A miss
-  -- conservatively returns the target (the existing semantics for
-  -- non-deduped addresses).
-  fn build_canon_addr_map_walk(addrs: List‹Addr›, consts: List‹&Constant›,
-                                seen_mptrs: List‹G›,
-                                seen_addrs: List‹Addr›,
-                                acc: RBTreeMap‹Addr›) -> RBTreeMap‹Addr› {
-    match load(addrs) {
-      ListNode.Nil => acc,
-      ListNode.Cons(addr, rest_a) =>
-        match load(consts) {
-          ListNode.Cons(c, rest_c) =>
-            let mptr = extract_muts_members_ptr(c);
-            match mptr {
-              0 => build_canon_addr_map_walk(rest_a, rest_c, seen_mptrs, seen_addrs, acc),
-              _ =>
-                let canon_addr = find_canon_addr_for_mptr(mptr, seen_mptrs, seen_addrs, addr);
-                let new_seen_mptrs = store(ListNode.Cons(mptr, seen_mptrs));
-                let new_seen_addrs = store(ListNode.Cons(canon_addr, seen_addrs));
-                let new_acc = rbtree_map_insert(ptr_val(addr), canon_addr, acc);
-                build_canon_addr_map_walk(rest_a, rest_c, new_seen_mptrs, new_seen_addrs, new_acc),
-            },
-        },
-    }
-  }
-
-  fn build_canon_addr_map(addrs: List‹Addr›, consts: List‹&Constant›) -> RBTreeMap‹Addr› {
-    build_canon_addr_map_walk(addrs, consts, store(ListNode.Nil), store(ListNode.Nil), RBTreeMap.Nil)
-  }
-
-  -- O(log N) canon-addr probe. Miss returns target unchanged (the
-  -- non-deduped case is the common one).
-  fn lookup_canon_addr(target: Addr, canon_addr_map: &RBTreeMap‹Addr›) -> Addr {
-    match load(canon_addr_map) {
-      RBTreeMap.Nil => target,
-      _ =>
-        let hit = rbtree_map_lookup_or_default(ptr_val(target), load(canon_addr_map), target);
-        hit,
-    }
-  }
-
-  -- Build kernel positions of each member's Indc within the block expansion.
-  -- pos[i] = block_start + sum(member_kernel_size(members[0..i])).
-  fn build_recur_idxs(members: List‹MutConst›, block_start: G, _member_idx: G) -> List‹G› {
-    build_recur_idxs_walk(members, block_start)
-  }
-
-  fn build_recur_idxs_walk(members: List‹MutConst›, cur_pos: G) -> List‹G› {
-    match load(members) {
-      ListNode.Nil => store(ListNode.Nil),
-      ListNode.Cons(mc, rest) =>
-        store(ListNode.Cons(cur_pos,
-          build_recur_idxs_walk(rest, cur_pos + member_kernel_size(mc)))),
-    }
-  }
-
-  fn build_ctor_idxs(num_ctors: G, induct_pos: G, cidx: G) -> List‹G› {
-    match num_ctors {
-      0 => store(ListNode.Nil),
-      _ =>
-        store(ListNode.Cons(induct_pos + 1 + cidx,
-          build_ctor_idxs(num_ctors - 1, induct_pos, cidx + 1))),
-    }
-  }
-
-  fn build_rule_ctor_idxs(members: List‹MutConst›, block_start: G, _member_idx: G) -> List‹G› {
-    build_rule_ctor_idxs_walk(members, block_start)
-  }
-
-  fn build_rule_ctor_idxs_walk(members: List‹MutConst›, cur_pos: G) -> List‹G› {
-    match load(members) {
-      ListNode.Nil => store(ListNode.Nil),
-      ListNode.Cons(mc, rest) =>
-        match mc {
-          MutConst.Indc(ind) =>
-            match ind {
-              Inductive.Mk(_, _, _, _, _, ctors) =>
-                let num_ctors = list_length(ctors);
-                let this_ctors = build_ctor_idxs(num_ctors, cur_pos, 0);
-                let rest_ctors = build_rule_ctor_idxs_walk(rest,
-                  cur_pos + 1 + num_ctors);
-                list_concat(this_ctors, rest_ctors),
+            let mc = list_lookup_u64(members, idx);
+            match mc {
+              MutConst.Defn(d) =>
+                let hint = #load_constant_hint(dprj_addr);
+                let recur_addrs = build_recur_addrs(members, block_addr);
+                store(convert_definition(d, sharing, refs, recur_addrs, univs, hint)),
             },
-          MutConst.Defn(_) =>
-            build_rule_ctor_idxs_walk(rest, cur_pos + 1),
-          MutConst.Recr(_) =>
-            build_rule_ctor_idxs_walk(rest, cur_pos + 1),
-        },
-    }
-  }
-
-  -- ============================================================================
-  -- ConvertInput construction: expand Muts blocks into kernel constants
-  -- ============================================================================
-
-  -- Returns 1 if `members` contains at least one MutConst.Indc, else 0.
-  fn members_have_indc(members: List‹MutConst›) -> G {
-    match load(members) {
-      ListNode.Nil => 0,
-      ListNode.Cons(mc, rest) =>
-        match mc {
-          MutConst.Indc(_) => 1,
-          _ => members_have_indc(rest),
         },
     }
   }
 
-  -- Deref Expr.Share via the constant's sharing list.
-  fn deref_share(e: Expr, sharing: List‹&Expr›) -> Expr {
-    match e {
-      Expr.Share(idx) =>
-        let ListNode.Cons(e, _) = load(list_drop(sharing, flatten_u64(idx)));
-        deref_share(load(e), sharing),
-      _ => e,
-    }
-  }
-
-  -- Walk a recursor's typ skipping `n` leading Alls; return body Expr.
-  fn peel_n_alls_expr(e: Expr, n: G, sharing: List‹&Expr›) -> Expr {
-    match n {
-      0 => deref_share(e, sharing),
-      _ =>
-        match deref_share(e, sharing) {
-          Expr.All(_, body_ref) => peel_n_alls_expr(load(body_ref), n - 1, sharing),
-          _ => e,
-        },
-    }
-  }
-
-  -- Take an App-spine expression's head.
-  fn collect_app_spine_expr_head(e: Expr, sharing: List‹&Expr›) -> Expr {
-    match deref_share(e, sharing) {
-      Expr.App(f_ref, _) => collect_app_spine_expr_head(load(f_ref), sharing),
-      other => other,
-    }
-  }
-
-  -- Extract the inductive's address from a recursor's typ.
-  -- Walks past `n_skip = params + motives + minors + indices` foralls,
-  -- then takes the next forall's domain (major's type), peels the App-spine,
-  -- and reads the head Ref's address from the recursor's `refs` list.
-  -- Returns `[0;32]` if the head isn't a Ref (e.g. mutual self-rec via Rec).
-  fn rec_typ_to_inductive_addr(typ: Expr, n_skip: G, refs: List‹Addr›,
-                                sharing: List‹&Expr›) -> Addr {
-    let after_skip = peel_n_alls_expr(typ, n_skip, sharing);
-    match after_skip {
-      Expr.All(major_ty_ref, _) =>
-        let head = collect_app_spine_expr_head(load(major_ty_ref), sharing);
-        match head {
-          Expr.Ref(ref_idx_bytes, _) => list_lookup(refs, flatten_u64(ref_idx_bytes)),
-          _ => store([0u8; 32]),
-        },
-      _ => store([0u8; 32]),
-    }
-  }
-
-  -- For aux-only Recr blocks (Muts containing only Recrs/Defns, e.g. produced
-  -- by `compile_aux_block` in src/ix/compile/mutual.rs), the rule_ctor_idxs
-  -- must come from the *original* inductive block referenced by the enclosing
-  -- Constant's refs, not from `members` (which has no Indc). Resolve the
-  -- block by extracting the inductive's address from the recursor's typ
-  -- (rather than heuristically matching ctor counts among refs, which fails
-  -- when multiple in-scope inductives share the same number of ctors).
-  -- Returns `(rule_ctor_idxs, block_addr)`. The standalone-Recr caller
-  -- needs the block_addr to wrap the CKRecr input; the Muts-block caller
-  -- already has block_addr in scope and discards the second component.
-  -- Computing both together saves the standalone caller a redundant
-  -- `rec_typ_to_inductive_addr` + `load_verified_constant` chain.
-  fn build_aux_recr_ctor_idxs(
-    recr: Recursor,
-    refs: List‹Addr›,
-    sharing: List‹&Expr›,
-    all_addrs: List‹Addr›,
-    block_start_map: &RBTreeMap‹G›
-  ) -> (List‹G›, Addr) {
-    match recr {
-      Recursor.Mk(_, _, _, params, indices, motives, minors, &typ, _) =>
-        let n_skip = ((flatten_u64(params) + flatten_u64(motives))
-                      + flatten_u64(minors)) + flatten_u64(indices);
-        let ind_addr = rec_typ_to_inductive_addr(typ, n_skip, refs, sharing);
-        let ind_const = load_verified_constant(ind_addr);
-        match ind_const {
-          Constant.Mk(info, _, _, _) =>
-            match info {
-              ConstantInfo.IPrj(prj) =>
-                match prj {
-                  InductiveProj.Mk(member_idx, block_addr) =>
-                    let block_const = load_verified_constant(block_addr);
-                    match block_const {
-                      Constant.Mk(bi, _, _, _) =>
-                        match bi {
-                          ConstantInfo.Muts(other_members) =>
-                            let bs = lookup_block_start(block_addr, block_start_map);
-                            -- Mutual block: each recursor's rules cover only
-                            -- its OWN inductive's ctors. Slice the global
-                            -- rule_ctor_idxs to just this member's ctors.
-                            let idxs = extract_member_ctor_idxs(other_members, bs,
-                              flatten_u64(member_idx));
-                            (idxs, block_addr),
-                        },
-                    },
-                },
+  -- IPrj resolver: Inductive projection.
+  fn get_ci_iprj(block_addr: Addr, idx: G) -> &KConstantInfo {
+    let block_c = load_verified_constant(block_addr);
+    match block_c {
+      Constant.Mk(info, sharing, refs, univs) =>
+        match info {
+          ConstantInfo.Muts(members) =>
+            let mc = muts_member_at(members, idx);
+            match mc {
+              MutConst.Indc(ind) =>
+                let recur_addrs = build_recur_addrs(members, block_addr);
+                store(convert_inductive(ind, block_addr, idx,
+                                             sharing, refs, recur_addrs, univs)),
             },
         },
     }
   }
 
-  -- Extract kernel ctor positions for member at `target_idx` in `members`.
-  fn extract_member_ctor_idxs(members: List‹MutConst›, block_start: G,
-                              target_idx: G) -> List‹G› {
-    extract_member_ctor_idxs_walk(members, block_start, target_idx, 0)
-  }
-
-  fn extract_member_ctor_idxs_walk(members: List‹MutConst›, cur_pos: G,
-                                    target_idx: G, idx: G) -> List‹G› {
-    match load(members) {
-      ListNode.Nil => store(ListNode.Nil),
-      ListNode.Cons(mc, rest) =>
-        let mc_size = member_kernel_size(mc);
-        match eq_zero(idx - target_idx) {
-          1 =>
+  -- CPrj resolver: Constructor projection.
+  fn get_ci_cprj(block_addr: Addr, idx: G, cidx: G) -> &KConstantInfo {
+    let block_c = load_verified_constant(block_addr);
+    match block_c {
+      Constant.Mk(info, sharing, refs, univs) =>
+        match info {
+          ConstantInfo.Muts(members) =>
+            let mc = muts_member_at(members, idx);
             match mc {
               MutConst.Indc(ind) =>
                 match ind {
                   Inductive.Mk(_, _, _, _, _, ctors) =>
-                    build_ctor_idxs(list_length(ctors), cur_pos, 0),
-                },
-              _ => store(ListNode.Nil),
-            },
-          0 => extract_member_ctor_idxs_walk(rest, cur_pos + mc_size,
-                                              target_idx, idx + 1),
-        },
-    }
-  }
-
-  -- Expand a single MutConst member into ConvertInputs.
-  -- For Indc: emits 1 Induct + N Ctors.
-  -- For Recr: emits 1 Rec.
-  -- For Defn: emits 1 Defn.
-  fn expand_member(
-    mc: MutConst,
-    ctx: ConvertCtx,
-    members: List‹MutConst›,
-    block_start: G,
-    member_idx: G,
-    refs: List‹Addr›,
-    all_addrs: List‹Addr›,
-    block_start_map: &RBTreeMap‹G›,
-    block_addr: Addr
-  ) -> List‹&ConvertInput› {
-    match mc {
-      MutConst.Indc(ind) =>
-        match ind {
-          Inductive.Mk(_, _, _, _, _, ctors) =>
-            let num_ctors = list_length(ctors);
-            let induct_pos = block_start + member_offset(members, member_idx);
-            let ctor_idxs = build_ctor_idxs(num_ctors, induct_pos, 0);
-            let indc_input = ConvertInput.Mk(ctx, ConvertKind.CKIndc(ind, ctor_idxs, block_addr));
-            let ctor_inputs = expand_ctors(ctors, ctx, induct_pos);
-            store(ListNode.Cons(store(indc_input), ctor_inputs)),
-        },
-      MutConst.Recr(recr) =>
-        match members_have_indc(members) {
-          1 =>
-            let rule_ctor_idxs = build_rule_ctor_idxs(members, block_start, 0);
-            let input = ConvertInput.Mk(ctx, ConvertKind.CKRecr(recr, rule_ctor_idxs, block_addr));
-            store(ListNode.Cons(store(input), store(ListNode.Nil))),
-          0 =>
-            let sharing = match ctx { ConvertCtx.Mk(s, _, _, _, _) => s, };
-            let (rule_ctor_idxs, _) =
-              build_aux_recr_ctor_idxs(recr, refs, sharing, all_addrs, block_start_map);
-            let input = ConvertInput.Mk(ctx, ConvertKind.CKRecr(recr, rule_ctor_idxs, block_addr));
-            store(ListNode.Cons(store(input), store(ListNode.Nil))),
-        },
-      MutConst.Defn(defn) =>
-        -- Muts-block defs default to Regular(0) (hint=1). Per-member hints
-        -- aren't currently plumbed; standalone Defns get their actual hint
-        -- via load_constant_hint in build_convert_inputs.
-        let input = ConvertInput.Mk(ctx, ConvertKind.CKDefn(defn, 1));
-        store(ListNode.Cons(store(input), store(ListNode.Nil))),
-    }
-  }
-
-  fn expand_ctors(ctors: List‹Constructor›, ctx: ConvertCtx, induct_pos: G) -> List‹&ConvertInput› {
-    match load(ctors) {
-      ListNode.Nil => store(ListNode.Nil),
-      ListNode.Cons(ctor, rest) =>
-        let input = ConvertInput.Mk(ctx, ConvertKind.CKCtor(ctor, induct_pos));
-        store(ListNode.Cons(store(input), expand_ctors(rest, ctx, induct_pos))),
-    }
-  }
-
-  fn expand_members(
-    members: List‹MutConst›,
-    ctx: ConvertCtx,
-    all_members: List‹MutConst›,
-    block_start: G,
-    member_idx: G,
-    refs: List‹Addr›,
-    all_addrs: List‹Addr›,
-    block_start_map: &RBTreeMap‹G›,
-    block_addr: Addr
-  ) -> List‹&ConvertInput› {
-    match load(members) {
-      ListNode.Nil => store(ListNode.Nil),
-      ListNode.Cons(mc, rest) =>
-        let this = expand_member(mc, ctx, all_members, block_start, member_idx,
-          refs, all_addrs, block_start_map, block_addr);
-        let more = expand_members(rest, ctx, all_members, block_start, member_idx + 1,
-          refs, all_addrs, block_start_map, block_addr);
-        list_concat(this, more),
-    }
-  }
-
-  -- Build the full List‹&ConvertInput› by walking loaded constants.
-  -- Muts blocks are expanded into their members.
-  -- Projections are skipped (handled via block expansion).
-  -- Standalone constants are converted directly.
-  -- Unpack head + tail of an addrs list (parallel walker for build_convert_inputs).
-  fn unpack_head_addr(addrs: List‹Addr›) -> (Addr, List‹Addr›) {
-    match load(addrs) {
-      ListNode.Cons(a, r) => (a, r),
-    }
-  }
-
-  fn build_convert_inputs(
-    consts: List‹&Constant›,
-    cur_addrs: List‹Addr›,
-    all_addrs: List‹Addr›,
-    pos_map: List‹G›,
-    canon_addr_map: &RBTreeMap‹Addr›,
-    block_start_map: &RBTreeMap‹G›,
-    pos: G
-  ) -> List‹&ConvertInput› {
-    -- Built once here; threaded as the fast-path index for `lookup_addr_pos`.
-    -- The base map carries `pos+1` for each const; `augment_with_blob_refs`
-    -- then walks every const's `refs` and tags every previously-unregistered
-    -- ref with the BLOB sentinel (4294967295), so blob-ref lookups
-    -- short-circuit instead of falling through to the O(N) linear scan.
-    -- A fused single-pass version was tried and lost — Aiur's per-row width
-    -- tax made the merged fn more expensive than two narrower passes.
-    let base_map = build_addr_pos_map(all_addrs, pos_map);
-    let addr_pos_map = store(augment_with_blob_refs(consts, base_map));
-    build_convert_inputs_walk(consts, cur_addrs, all_addrs, addr_pos_map, pos_map,
-                              canon_addr_map, block_start_map, pos,
-                              store(ListNode.Nil))
-  }
-
-  fn build_convert_inputs_walk(
-    consts: List‹&Constant›,
-    cur_addrs: List‹Addr›,
-    all_addrs: List‹Addr›,
-    addr_pos_map: &RBTreeMap‹G›,
-    pos_map: List‹G›,
-    canon_addr_map: &RBTreeMap‹Addr›,
-    block_start_map: &RBTreeMap‹G›,
-    pos: G,
-    seen_mptrs: List‹G›
-  ) -> List‹&ConvertInput› {
-    match load(consts) {
-      ListNode.Nil => store(ListNode.Nil),
-      ListNode.Cons(&c, rest) =>
-        match unpack_head_addr(cur_addrs) {
-          (head_addr, rest_addrs) =>
-            match c {
-              Constant.Mk(info, sharing, refs, univs) =>
-                match info {
-                  ConstantInfo.Muts(members) =>
-                    let mptr = extract_dedup_mptr(c);
-                    let dup = match mptr {
-                      0 => 0,
-                      _ => is_mptr_seen(mptr, seen_mptrs),
-                    };
-                    match dup {
-                      1 =>
-                        -- Duplicate Muts: skip emission (canonical Muts already
-                        -- emitted). Don't advance pos. Refs to this wrapper
-                        -- resolve to canonical pos via pos_map dedup.
-                        build_convert_inputs_walk(rest, rest_addrs, all_addrs, addr_pos_map, pos_map,
-                          canon_addr_map, block_start_map, pos, seen_mptrs),
-                      0 =>
-                        let new_seen = match mptr {
-                          0 => seen_mptrs,
-                          _ => store(ListNode.Cons(mptr, seen_mptrs)),
-                        };
-                        let size = block_kernel_size(members);
-                        let canon_block_start = lookup_addr_pos(head_addr, addr_pos_map);
-                        let canon_addr = lookup_canon_addr(head_addr, canon_addr_map);
-                        let (ref_idxs, lit_blobs) =
-                          build_ref_idxs_and_blobs(refs, addr_pos_map);
-                        let recur_idxs = build_recur_idxs(members, canon_block_start, 0);
-                        let ctx = ConvertCtx.Mk(sharing, ref_idxs, recur_idxs, lit_blobs, univs);
-                        let expanded = expand_members(members, ctx, members, canon_block_start, 0,
-                          refs, all_addrs, block_start_map, canon_addr);
-                        let more = build_convert_inputs_walk(rest, rest_addrs, all_addrs, addr_pos_map, pos_map,
-                          canon_addr_map, block_start_map, pos + size, new_seen);
-                        list_concat(expanded, more),
-                    },
-                  ConstantInfo.IPrj(_) =>
-                    build_convert_inputs_walk(rest, rest_addrs, all_addrs, addr_pos_map, pos_map, canon_addr_map, block_start_map, pos, seen_mptrs),
-                  ConstantInfo.CPrj(_) =>
-                    build_convert_inputs_walk(rest, rest_addrs, all_addrs, addr_pos_map, pos_map, canon_addr_map, block_start_map, pos, seen_mptrs),
-                  ConstantInfo.RPrj(_) =>
-                    build_convert_inputs_walk(rest, rest_addrs, all_addrs, addr_pos_map, pos_map, canon_addr_map, block_start_map, pos, seen_mptrs),
-                  ConstantInfo.DPrj(_) =>
-                    build_convert_inputs_walk(rest, rest_addrs, all_addrs, addr_pos_map, pos_map, canon_addr_map, block_start_map, pos, seen_mptrs),
-                  ConstantInfo.Defn(defn) =>
-                    let (ref_idxs, lit_blobs) =
-                      build_ref_idxs_and_blobs(refs, addr_pos_map);
-                    let recur_idxs = store(ListNode.Cons(pos, store(ListNode.Nil)));
-                    let ctx = ConvertCtx.Mk(sharing, ref_idxs, recur_idxs, lit_blobs, univs);
-                    let hint = #load_constant_hint(head_addr);
-                    let input = ConvertInput.Mk(ctx, ConvertKind.CKDefn(defn, hint));
-                    store(ListNode.Cons(store(input),
-                      build_convert_inputs_walk(rest, rest_addrs, all_addrs, addr_pos_map, pos_map, canon_addr_map, block_start_map, pos + 1, seen_mptrs))),
-                  ConstantInfo.Axio(axio) =>
-                    let (ref_idxs, lit_blobs) =
-                      build_ref_idxs_and_blobs(refs, addr_pos_map);
-                    let ctx = ConvertCtx.Mk(sharing, ref_idxs, store(ListNode.Nil), lit_blobs, univs);
-                    let input = ConvertInput.Mk(ctx, ConvertKind.CKAxio(axio));
-                    store(ListNode.Cons(store(input),
-                      build_convert_inputs_walk(rest, rest_addrs, all_addrs, addr_pos_map, pos_map, canon_addr_map, block_start_map, pos + 1, seen_mptrs))),
-                  ConstantInfo.Quot(quot) =>
-                    let (ref_idxs, lit_blobs) =
-                      build_ref_idxs_and_blobs(refs, addr_pos_map);
-                    let ctx = ConvertCtx.Mk(sharing, ref_idxs, store(ListNode.Nil), lit_blobs, univs);
-                    let input = ConvertInput.Mk(ctx, ConvertKind.CKQuot(quot));
-                    store(ListNode.Cons(store(input),
-                      build_convert_inputs_walk(rest, rest_addrs, all_addrs, addr_pos_map, pos_map, canon_addr_map, block_start_map, pos + 1, seen_mptrs))),
-                  ConstantInfo.Recr(recr) =>
-                    let (ref_idxs, lit_blobs) =
-                      build_ref_idxs_and_blobs(refs, addr_pos_map);
-                    -- `build_aux_recr_ctor_idxs` already does the typ-peel +
-                    -- IPrj lookup to find the recursor's inductive block;
-                    -- get block_addr from the same call instead of redoing
-                    -- the `rec_typ_to_inductive_addr` + `load_verified_constant`
-                    -- chain.
-                    let (rule_ctor_idxs, block_addr) = build_aux_recr_ctor_idxs(
-                      recr, refs, sharing, all_addrs, block_start_map);
-                    let recur_idxs = store(ListNode.Cons(pos, store(ListNode.Nil)));
-                    let ctx = ConvertCtx.Mk(sharing, ref_idxs, recur_idxs, lit_blobs, univs);
-                    let input = ConvertInput.Mk(ctx, ConvertKind.CKRecr(recr, rule_ctor_idxs, block_addr));
-                    store(ListNode.Cons(store(input),
-                      build_convert_inputs_walk(rest, rest_addrs, all_addrs, addr_pos_map, pos_map, canon_addr_map, block_start_map, pos + 1, seen_mptrs))),
+                    let c = ctor_at(ctors, cidx);
+                    let recur_addrs = build_recur_addrs(members, block_addr);
+                    store(convert_constructor(c, block_addr, idx,
+                                                  sharing, refs, recur_addrs, univs)),
                 },
             },
         },
     }
   }
 
-  -- ============================================================================
-  -- Loading and dependency tracking
-  -- ============================================================================
-
-  -- Recursively load constants and their transitive dependencies.
-  -- Processes one address at a time from a worklist, deduplicating by
-  -- checking the visited set. Blob addresses are detected via io_get_info:
-  -- the prover provides len=0 for blobs (which are not serialized constants).
-  -- For projection constants (IPrj, CPrj, RPrj, DPrj), also follows the
-  -- Muts block's refs so that all dependencies of block members are loaded.
-  fn load_with_deps(
-    addr: Addr,
-    worklist: List‹Addr›,
-    visited_addrs: List‹Addr›,
-    visited_consts: List‹&Constant›,
-    visited_set: RBTreeMap‹G›
-  ) -> (List‹Addr›, List‹&Constant›) {
-    let already = rbtree_map_lookup_or_default(ptr_val(addr), visited_set, 0);
-    match already {
-      1 =>
-        match load(worklist) {
-          ListNode.Nil => (visited_addrs, visited_consts),
-          ListNode.Cons(next, rest) =>
-            load_with_deps(next, rest, visited_addrs, visited_consts, visited_set),
-        },
-      _ =>
-        -- Discriminator on ch 4: 1 = const, 0 = blob. The host
-        -- (`addEntries`) seeds exactly one byte per addr it ships.
-        -- Soundness via erasure-correctness: lying flips the const/blob
-        -- decision, and the wrong-path load fails downstream (a "blob"
-        -- const won't get its bytes ingressed → refs to it dangle →
-        -- typecheck fail; a "const" blob triggers a ch 2 read that
-        -- returns empty → blake3 verify against the non-empty addr
-        -- fails).
-        let (idx, len) = io_get_info(4, load(addr));
-        let kind_bytes = #read_byte_stream(4, idx, len);
-        let kind = match load(kind_bytes) {
-          ListNode.Cons(b, _) => to_field(b),
-        };
-        match kind {
-          0 =>
-            -- Blob address: skip (blob values are loaded on demand in build_lit_blobs)
-            match load(worklist) {
-              ListNode.Nil => (visited_addrs, visited_consts),
-              ListNode.Cons(next, rest) =>
-                load_with_deps(next, rest, visited_addrs, visited_consts, visited_set),
-            },
-          _ =>
-            let new_addrs = store(ListNode.Cons(addr, visited_addrs));
-            let new_set = rbtree_map_insert(ptr_val(addr), 1, visited_set);
-            let constant = load_verified_constant(addr);
-            let new_consts = store(ListNode.Cons(store(constant), visited_consts));
-            match constant {
-              Constant.Mk(info, _, refs, _) =>
-                let block_addr = get_proj_block_addr(info);
-                match address_eq(block_addr, store([0u8; 32])) {
-                  1 =>
-                    let combined_refs = list_concat(refs, store(ListNode.Nil));
-                    let next_worklist = list_concat(combined_refs, worklist);
-                    match load(next_worklist) {
-                      ListNode.Nil => (new_addrs, new_consts),
-                      ListNode.Cons(next, rest) =>
-                        load_with_deps(next, rest, new_addrs, new_consts, new_set),
-                    },
-                  0 =>
-                    let combined_refs = list_concat(
-                      refs,
-                      store(ListNode.Cons(block_addr, store(ListNode.Nil)))
-                    );
-                    let next_worklist = list_concat(combined_refs, worklist);
-                    match load(next_worklist) {
-                      ListNode.Nil => (new_addrs, new_consts),
-                      ListNode.Cons(next, rest) =>
-                        load_with_deps(next, rest, new_addrs, new_consts, new_set),
-                    },
-                },
-            },
-        },
-    }
-  }
-
-  -- Transitively loads all dependencies of the target constant from IOBuffer,
-  -- verifies blake3 hashes then converts to kernel types.
-  fn ingress(target_addr: Addr) -> List‹&KConstantInfo› {
-    let (all_addrs, all_consts) = load_with_deps(
-      target_addr, store(ListNode.Nil), store(ListNode.Nil), store(ListNode.Nil), RBTreeMap.Nil);
-    let (block_addrs, block_starts, _total) = compute_layout(all_consts, all_addrs, 0);
-    let block_start_map = store(build_block_start_map(block_addrs, block_starts));
-    let pos_map_naive = build_pos_map(all_consts, all_addrs, block_start_map, 0);
-    let pos_map = canonicalize_pos_map(all_consts, pos_map_naive);
-    let canon_addr_map = store(build_canon_addr_map(all_addrs, all_consts));
-    let inputs = build_convert_inputs(all_consts, all_addrs, all_addrs, pos_map, canon_addr_map, block_start_map, 0);
-    convert_all(inputs)
-  }
-
-  -- Build a List‹Addr› parallel to k_consts: addrs[i] = blake3 address
-  -- of the kernel const at position i. Walks (all_addrs, pos_map) and for
-  -- each kernel position emits the addr that resolves to it.
-  -- Address-keyed dispatch: primitives compared by address, not by
-  -- precomputed positional index.
-  fn build_addrs_aligned(i: G, total: G,
-                         all_addrs: List‹Addr›,
-                         all_consts: List‹&Constant›,
-                         pos_map: List‹G›) -> List‹Addr› {
-    match i - total {
-      0 => store(ListNode.Nil),
-      _ =>
-        let addr = find_best_addr_at_pos(i, all_addrs, all_consts, pos_map);
-        store(ListNode.Cons(addr, build_addrs_aligned(i + 1, total, all_addrs, all_consts, pos_map))),
-    }
-  }
-
-  -- Returns 1 if `c` is a projection constant (IPrj/CPrj/RPrj/DPrj).
-  -- Used to prioritize per-member primitive addresses over the parent
-  -- Muts block's content-hash when both share the same kernel position.
-  fn is_proj_const(c: &Constant) -> G {
-    match load(c) {
-      Constant.Mk(info, _, _, _) =>
+  -- RPrj resolver: Recursor projection.
+  fn get_ci_rprj(block_addr: Addr, idx: G) -> &KConstantInfo {
+let block_c = load_verified_constant(block_addr);
+    match block_c {
+      Constant.Mk(info, sharing, refs, univs) =>
         match info {
-          ConstantInfo.IPrj(_) => 1,
-          ConstantInfo.CPrj(_) => 1,
-          ConstantInfo.RPrj(_) => 1,
-          ConstantInfo.DPrj(_) => 1,
-          _ => 0,
-        },
-    }
-  }
-
-  -- First pass: find a projection-constant entry whose pos_map = `target`.
-  -- Per-member primitive addrs (e.g. `nat_addr`) live on IPrj entries;
-  -- the parent Muts block has the BLOCK content-hash, not the member's.
-  -- So we prefer the IPrj-derived addr at a shared pos.
-  fn find_prj_addr_at_pos(target: G, all_addrs: List‹Addr›,
-                           all_consts: List‹&Constant›,
-                           pos_map: List‹G›) -> (G, Addr) {
-    match load(all_addrs) {
-      ListNode.Nil => (0, store([0u8; 32])),
-      ListNode.Cons(addr, rest_a) =>
-        match load(all_consts) {
-          ListNode.Cons(c, rest_c) =>
-            match load(pos_map) {
-              ListNode.Cons(pos, rest_p) =>
-                let pos_match = eq_zero(pos - target);
-                let prj = is_proj_const(c);
-                match pos_match * prj {
-                  1 => (1, addr),
-                  _ => find_prj_addr_at_pos(target, rest_a, rest_c, rest_p),
-                },
-            },
-        },
-    }
-  }
-
-  -- Find the address in all_addrs whose pos_map entry equals `target`.
-  -- Returns all-zero `Addr` if not found — happens for kernel
-  -- positions that are only reached via within-block peer refs
-  -- (Expr.Rec) and never loaded as a standalone ref. Primitive
-  -- dispatch via `address_eq` against hardcoded non-zero addresses
-  -- treats zero-addr as "no primitive here", falling through.
-  fn find_addr_at_pos(target: G, all_addrs: List‹Addr›, pos_map: List‹G›) -> Addr {
-    match load(all_addrs) {
-      ListNode.Nil => store([0u8; 32]),
-      ListNode.Cons(addr, rest_addrs) =>
-        match load(pos_map) {
-          ListNode.Cons(pos, rest_pos) =>
-            match pos - target {
-              0 => addr,
-              _ => find_addr_at_pos(target, rest_addrs, rest_pos),
-            },
-        },
-    }
-  }
-
-  -- Wrapper: prefer Prj-derived addr at shared pos, fall back to any.
-  fn find_best_addr_at_pos(target: G, all_addrs: List‹Addr›,
-                            all_consts: List‹&Constant›,
-                            pos_map: List‹G›) -> Addr {
-    match find_prj_addr_at_pos(target, all_addrs, all_consts, pos_map) {
-      (1, addr) => addr,
-      (0, _) => find_addr_at_pos(target, all_addrs, pos_map),
-    }
-  }
-
-  -- ============================================================================
-  -- Tree-based addr table construction.
-  --
-  -- Replaces the O(N²) `build_addrs_aligned` (which scanned `all_addrs`
-  -- once per kernel position). Builds a pos→Addr RBTreeMap by walking
-  -- the input lists twice: non-PRJ pass first, PRJ pass second so PRJ
-  -- entries overwrite non-PRJ at shared kernel positions (per the
-  -- PRJ-priority semantics in `find_best_addr_at_pos`). Then emits a
-  -- position-indexed `List‹Addr›` for downstream compatibility.
-  -- O(N log N) build + emit total.
-  -- ============================================================================
-
-  fn build_addr_tree_walk(addrs: List‹Addr›,
-                          consts: List‹&Constant›,
-                          pos_map: List‹G›,
-                          want_prj: G,
-                          tree: RBTreeMap‹Addr›) -> RBTreeMap‹Addr› {
-    match load(addrs) {
-      ListNode.Nil => tree,
-      ListNode.Cons(addr, rest_a) =>
-        match load(consts) {
-          ListNode.Cons(c, rest_c) =>
-            match load(pos_map) {
-              ListNode.Cons(pos, rest_p) =>
-                let is_prj = is_proj_const(c);
-                match is_prj - want_prj {
-                  0 =>
-                    let new_tree = rbtree_map_insert(pos, addr, tree);
-                    build_addr_tree_walk(rest_a, rest_c, rest_p, want_prj, new_tree),
-                  _ =>
-                    build_addr_tree_walk(rest_a, rest_c, rest_p, want_prj, tree),
-                },
+          ConstantInfo.Muts(members) =>
+            let mc = muts_member_at(members, idx);
+            match mc {
+              MutConst.Recr(r) =>
+                let recur_addrs = build_recur_addrs(members, block_addr);
+                store(convert_recursor(r, block_addr, idx,
+                                           sharing, refs, recur_addrs, univs)),
             },
         },
     }
   }
 
-  fn build_addr_tree(all_addrs: List‹Addr›,
-                     all_consts: List‹&Constant›,
-                     pos_map: List‹G›) -> RBTreeMap‹Addr› {
-    let t = build_addr_tree_walk(all_addrs, all_consts, pos_map, 0, RBTreeMap.Nil);
-    build_addr_tree_walk(all_addrs, all_consts, pos_map, 1, t)
-  }
-
-  -- Apply ctor overrides as tree updates. Each (pos, addr) in
-  -- `overrides` replaces the entry at `pos`. O(K log N) for K overrides.
-  fn apply_ctor_overrides_tree(overrides: List‹(G, Addr)›,
-                               tree: RBTreeMap‹Addr›) -> RBTreeMap‹Addr› {
-    match load(overrides) {
-      ListNode.Nil => tree,
-      ListNode.Cons(p, rest) =>
-        match p {
-          (pos, addr) =>
-            let new_tree = rbtree_map_insert(pos, addr, tree);
-            apply_ctor_overrides_tree(rest, new_tree),
-        },
-    }
-  }
-
-  -- Emit the position-indexed `List‹Addr›` from a pos→Addr tree.
-  -- Positions absent from the tree map to `zero_addr` (matches the
-  -- semantics of `find_best_addr_at_pos` which returned a zero addr
-  -- for uncovered positions).
-  fn emit_addrs_from_tree(i: G, total: G, tree: RBTreeMap‹Addr›,
-                          zero_addr: Addr) -> List‹Addr› {
-    match total - i {
-      0 => store(ListNode.Nil),
-      _ =>
-        let addr = rbtree_map_lookup_or_default(i, tree, zero_addr);
-        store(ListNode.Cons(addr,
-          emit_addrs_from_tree(i + 1, total, tree, zero_addr))),
-    }
-  }
-
-  -- Returns `(k_consts, addrs)` where `addrs[i]` is the blake3 address of
-  -- the kernel const at position `i`. Primitive detection downstream
-  -- compares addresses via `address_eq` against hardcoded constants
-  -- in `Primitive.lean`.
-  -- Build override list (ctor_pos → ctor_addr) by walking every loaded
-  -- IPrj. For each, find the inductive's ctor count from the parent
-  -- block and synthesize each ctor's CPrj content-hash via in-Aiur
-  -- `put_constant` + `blake3`. No IO buffer side channel needed: every
-  -- input (idx, block_addr, cidx) is either taken from a `load_verified_*`
-  -- result or a deterministic loop counter, so the resulting addresses
-  -- are derived from already-trusted data.
-  fn build_ctor_overrides(all_consts: List‹&Constant›, all_addrs: List‹Addr›,
-                          block_start_map: &RBTreeMap‹G›)
-                          -> List‹(G, Addr)› {
-    match load(all_consts) {
-      ListNode.Nil => store(ListNode.Nil),
-      ListNode.Cons(&c, rest_c) =>
-        match load(all_addrs) {
-          ListNode.Cons(_, rest_a) =>
-            match c {
-              Constant.Mk(info, _, _, _) =>
-                match info {
-                  ConstantInfo.IPrj(prj) =>
-                    match prj {
-                      InductiveProj.Mk(idx, block_addr) =>
-                        let block_start = lookup_block_start(block_addr, block_start_map);
-                        let block_const = load_verified_constant(block_addr);
-                        match block_const {
-                          Constant.Mk(bi, _, _, _) =>
-                            match bi {
-                              ConstantInfo.Muts(members) =>
-                                let mem_off = member_offset(members, flatten_u64(idx));
-                                let base_pos = block_start + mem_off + 1;
-                                let n_ctors = inductive_ctor_count_at(members, flatten_u64(idx));
-                                let new_pairs = build_ctor_pairs_computed(idx, block_addr, base_pos, n_ctors, 0);
-                                list_concat(new_pairs,
-                                  build_ctor_overrides(rest_c, rest_a, block_start_map)),
-                              _ =>
-                                build_ctor_overrides(rest_c, rest_a, block_start_map),
-                            },
-                        },
-                    },
-                  _ =>
-                    build_ctor_overrides(rest_c, rest_a, block_start_map),
-                },
-            },
+  -- Muts direct: return first member's KCI (fallback).
+  fn get_ci_muts_member(muts_addr: Addr, members: List‹MutConst›,
+                             idx: G) -> &KConstantInfo {
+    let block_c = load_verified_constant(muts_addr);
+    match block_c {
+      Constant.Mk(_, sharing, refs, univs) =>
+        let mc = muts_member_at(members, idx);
+        let recur_addrs = build_recur_addrs(members, muts_addr);
+        match mc {
+          MutConst.Defn(d) =>
+            let hint = #load_constant_hint(muts_addr);
+            store(convert_definition(d, sharing, refs, recur_addrs, univs, hint)),
+          MutConst.Indc(ind) =>
+            store(convert_inductive(ind, muts_addr, idx,
+                                         sharing, refs, recur_addrs, univs)),
+          MutConst.Recr(r) =>
+            store(convert_recursor(r, muts_addr, idx,
+                                       sharing, refs, recur_addrs, univs)),
         },
     }
   }
 
-  -- Number of constructors of the Inductive at `target_idx` within the
-  -- given Muts members. Returns 0 if the indexed member isn't an Inductive.
-  fn inductive_ctor_count_at(members: List‹MutConst›, target_idx: G) -> G {
-    inductive_ctor_count_walk(members, target_idx, 0)
-  }
-
-  fn inductive_ctor_count_walk(members: List‹MutConst›, target_idx: G, i: G) -> G {
+  -- G-indexed Muts member lookup.
+  fn muts_member_at(members: List‹MutConst›, idx: G) -> MutConst {
     match load(members) {
-      ListNode.Nil => 0,
-      ListNode.Cons(mc, rest) =>
-        match i - target_idx {
-          0 =>
-            match mc {
-              MutConst.Indc(ind) =>
-                match ind {
-                  Inductive.Mk(_, _, _, _, _, ctors) =>
-                    list_length(ctors),
-                },
-              _ => 0,
-            },
-          _ => inductive_ctor_count_walk(rest, target_idx, i + 1),
+      ListNode.Cons(m, rest) =>
+        match idx {
+          0 => m,
+          _ => muts_member_at(rest, idx - 1),
         },
     }
   }
 
-  fn build_ctor_pairs_computed(idx: U64, block: Addr,
-                                base_pos: G, n_ctors: G, cidx: G)
-                                -> List‹(G, Addr)› {
-    match n_ctors - cidx {
-      0 => store(ListNode.Nil),
-      _ =>
-        let addr = cprj_content_addr(idx, cidx, block);
-        store(ListNode.Cons((base_pos + cidx, addr),
-          build_ctor_pairs_computed(idx, block, base_pos, n_ctors, cidx + 1))),
-    }
+  -- Pack a member/ctor index into the u64 projection field as a
+  -- little-endian [U8; 8].
+  --
+  -- The bytes come from the `unconstrained_g_to_bytes` hint and are then
+  -- CONSTRAINED, because field -> bytes is not free: `flatten_u64` goes
+  -- bytes -> field for nothing, but the reverse needs the bytes supplied
+  -- as advice and pinned. Three obligations, all discharged here:
+  --
+  --   * every byte is range-checked into [0, 256) (`u8_range_check`
+  --     takes a pair per lookup row, so eight bytes cost four);
+  --   * the bytes must RECOMPOSE to `idx`;
+  --   * the recomposition must be CANONICAL. This one is load-bearing:
+  --     Goldilocks is 2^64 - 2^32 + 1, so an arbitrary eight-byte string
+  --     is not injective into the field — values at or above `p` wrap,
+  --     and a prover could hand over a second string recomposing to the
+  --     same element.
+  --
+  -- Uniqueness is the soundness property, since the synthesized
+  -- projection address is blake3 over these serialized bytes: a prover
+  -- free to pick a different string for one index would get a second
+  -- address for a member, or collide two members onto one address. The
+  -- earlier `u8_from_field_unsafe` version truncated and did exactly
+  -- that for members 0 and 256.
+  --
+  -- Indices at or beyond 2^56 fail the assert rather than truncating
+  -- silently — a liveness bound only, and far past any real block or
+  -- constructor count.
+  fn idx_to_u64(idx: G) -> U64 {
+    let [h0, h1, h2, h3, h4, h5, h6, h7] = unconstrained_g_to_bytes(idx);
+    let (b0, b1) = u8_range_check(to_field(h0), to_field(h1));
+    let (b2, b3) = u8_range_check(to_field(h2), to_field(h3));
+    let (b4, b5) = u8_range_check(to_field(h4), to_field(h5));
+    let (b6, b7) = u8_range_check(to_field(h6), to_field(h7));
+    let bytes = [b0, b1, b2, b3, b4, b5, b6, b7];
+    -- `flatten_u64` contributes the top-byte-is-zero assert and the sum.
+    -- It does NOT range-check its input and so is not injective on its
+    -- own; uniqueness here holds only because the range checks above
+    -- bound every byte. Both halves are load-bearing — dropping either
+    -- lets a prover pick a second byte string for the same index.
+    assert_eq!(flatten_u64(bytes), idx,
+      "projection index bytes do not recompose to the index");
+    bytes
   }
 
-  -- Compute the CPrj's blake3 content-hash from `(idx, cidx, block)` by
-  -- constructing the same `Constant{ info := CPrj{...}, ... }` shape Lean
-  -- compile uses, serializing it in-Aiur, and hashing. No external trust
-  -- needed — every input is derived from a `load_verified_*` result or a
-  -- loop counter.
-  fn cprj_content_addr(idx: U64, cidx: G, block: Addr) -> Addr {
-    let prj = ConstructorProj.Mk(idx, [u8_from_field_unsafe(cidx), 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], block);
-    let info = ConstantInfo.CPrj(prj);
-    let cnst = Constant.Mk(info, store(ListNode.Nil),
-                                  store(ListNode.Nil),
-                                  store(ListNode.Nil));
-    let bytes = put_constant(cnst, store(ListNode.Nil));
+  -- Synthesize the projection-wrapper Addr for Muts member at idx.
+  -- Serializes the projection Constant (empty sharing/refs/univs) and
+  -- blake3-hashes it — same output as Ixon compile's emitted projection
+  -- wrapper. Aiur memoizes per (members, block_addr, idx). Used by
+  -- convert_expr's Rec arm to resolve intra-Muts references.
+  fn projection_addr(members: List‹MutConst›, block_addr: Addr, idx: G) -> Addr {
+    let mc = muts_member_at(members, idx);
+    let idx_u64 = idx_to_u64(idx);
+    let info = match mc {
+      MutConst.Defn(_) =>
+        ConstantInfo.DPrj(DefinitionProj.Mk(idx_u64, block_addr)),
+      MutConst.Indc(_) =>
+        ConstantInfo.IPrj(InductiveProj.Mk(idx_u64, block_addr)),
+      MutConst.Recr(_) =>
+        ConstantInfo.RPrj(RecursorProj.Mk(idx_u64, block_addr)),
+    };
+    let proj_c = Constant.Mk(info,
+                              store(ListNode.Nil),
+                              store(ListNode.Nil),
+                              store(ListNode.Nil));
+    let bytes = put_constant(proj_c, store(ListNode.Nil));
     bytes_to_addr(bytes)
   }
 
-
-  fn ingress_with_primitives(target_addr: Addr) -> (List‹&KConstantInfo›, List‹Addr›) {
-    let (all_addrs, all_consts) = load_with_deps(
-      target_addr, store(ListNode.Nil), store(ListNode.Nil), store(ListNode.Nil), RBTreeMap.Nil);
-    finish_ingress(all_addrs, all_consts)
-  }
-
-  -- Ingress the UNION closure of all env leaves in a single pass. One
-  -- `load_with_deps` over leaves[0] as target with the remaining leaves as
-  -- the initial worklist loads every leaf + its transitive deps; then the
-  -- shared `finish_ingress` pipeline runs ONCE over the union, rather than
-  -- being re-run per leaf as CheckEnv previously did.
-  fn ingress_env(leaves: List‹Addr›) -> (List‹&KConstantInfo›, List‹Addr›) {
-    match load(leaves) {
-      ListNode.Nil => synthetic_primitive_entries(),
-      ListNode.Cons(first, rest) =>
-        let (all_addrs, all_consts) = load_with_deps(
-          first, rest, store(ListNode.Nil), store(ListNode.Nil), RBTreeMap.Nil);
-        finish_ingress(all_addrs, all_consts),
-    }
-  }
-
-  -- Shared post-load pipeline: layout, conversion, addr table, primitives.
-  fn finish_ingress(all_addrs: List‹Addr›, all_consts: List‹&Constant›)
-                    -> (List‹&KConstantInfo›, List‹Addr›) {
-    let (block_addrs, block_starts, total) = compute_layout(all_consts, all_addrs, 0);
-    let block_start_map = store(build_block_start_map(block_addrs, block_starts));
-    let pos_map_naive = build_pos_map(all_consts, all_addrs, block_start_map, 0);
-    -- Canonicalize duplicate Muts wrappers (same members-Ptr) so refs
-    -- converge AND emitted KConstantInfos share content via store dedup.
-    let pos_map = canonicalize_pos_map(all_consts, pos_map_naive);
-    let canon_addr_map = store(build_canon_addr_map(all_addrs, all_consts));
-    let inputs = build_convert_inputs(all_consts, all_addrs, all_addrs, pos_map, canon_addr_map, block_start_map, 0);
-    let k_consts = convert_all(inputs);
-    -- Build the pos→Addr tree via two O(N) passes (non-PRJ then PRJ
-    -- overwrites at shared positions). Replaces the prior O(N²)
-    -- `build_addrs_aligned` + `find_best_addr_at_pos` linear scans.
-    let tree = build_addr_tree(all_addrs, all_consts, pos_map);
-    -- Patch ctor positions: parent Inductives don't surface their ctors'
-    -- CPrj addresses via Lean's compile (non-aux ctors aren't stored in
-    -- env.consts). We surface them via the `[3] ++ ipr_addr` IO-buffer
-    -- side channel and inject them as tree updates.
-    let overrides = build_ctor_overrides(all_consts, all_addrs, block_start_map);
-    let tree = apply_ctor_overrides_tree(overrides, tree);
-    let zero_addr = store([0u8; 32]);
-    let addrs = emit_addrs_from_tree(0, total, tree, zero_addr);
-    -- Append synthetic primitive entries with their hardcoded addresses.
-    -- The Aiur kernel's index-based `KExprNode.Const` references need a
-    -- top position for every primitive that internal expansions
-    -- (e.g. `str_lit_to_ctor`) construct. When the target's transitive
-    -- closure doesn't load a primitive, the synthetic stub at the end
-    -- provides a discoverable position. Each stub is an
-    -- `Axiom Sort 0` that type-checks trivially. Real loaded primitives
-    -- still appear earlier in `addrs` so `find_addr_idx_safe` returns
-    -- their true position; the stub is only consulted when the real
-    -- one is absent.
-    let (prim_consts, prim_addrs_list) = synthetic_primitive_entries();
-    let k_consts = list_concat(k_consts, prim_consts);
-    let addrs = list_concat(addrs, prim_addrs_list);
-    (k_consts, addrs)
+  -- Build List<Addr> of projection addrs for a block's members, parallel
+  -- to `members`. Consumed by convert_expr Rec arm as recur_addrs.
+  fn build_recur_addrs(members: List‹MutConst›, block_addr: Addr) -> List‹Addr› {
+    build_recur_addrs_walk(members, block_addr, members, 0)
   }
 
-  -- Synthetic primitive entries: every hardcoded `*_addr()` from
-  -- `Ix.IxVM.Kernel.Primitive`, paired with a stub `Axiom Sort 0`.
-  -- Order doesn't matter since lookup is by address. Mirrors the full
-  -- `Primitives<M>` set in `src/ix/kernel/primitive.rs`. When the
-  -- target's transitive closure already loads a real primitive, that
-  -- entry appears earlier in `addrs` and `find_addr_idx_safe` returns
-  -- its true position; the stub is only consulted otherwise.
-  fn synthetic_primitive_entries() -> (List‹&KConstantInfo›, List‹Addr›) {
-    let addrs = synthetic_primitive_addrs();
-    let stub_ty = store(KExprNode.Srt(store(KLevelNode.Zero)));
-    let stub = store(KConstantInfo.Axiom(0, stub_ty, 0));
-    let consts = list_repeat_stub(stub, list_addr_length(addrs));
-    (consts, addrs)
-  }
-
-  fn synthetic_primitive_addrs() -> List‹Addr› {
-    store(ListNode.Cons(quot_type_addr(),
-    store(ListNode.Cons(quot_ctor_addr(),
-    store(ListNode.Cons(quot_lift_addr(),
-    store(ListNode.Cons(quot_ind_addr(),
-    store(ListNode.Cons(bit_vec_addr(),
-    store(ListNode.Cons(bit_vec_to_nat_addr(),
-    store(ListNode.Cons(bit_vec_of_nat_addr(),
-    store(ListNode.Cons(bit_vec_ult_addr(),
-    store(ListNode.Cons(decidable_decide_addr(),
-    store(ListNode.Cons(lt_lt_addr(),
-    store(ListNode.Cons(bool_type_addr(),
-    store(ListNode.Cons(eq_addr(),
-    store(ListNode.Cons(eq_refl_addr(),
-    store(ListNode.Cons(nat_dec_le_addr(),
-    store(ListNode.Cons(nat_dec_eq_addr(),
-    store(ListNode.Cons(nat_dec_lt_addr(),
-    store(ListNode.Cons(int_dec_eq_addr(),
-    store(ListNode.Cons(int_dec_le_addr(),
-    store(ListNode.Cons(int_dec_lt_addr(),
-    store(ListNode.Cons(int_of_nat_addr(),
-    store(ListNode.Cons(int_neg_succ_addr(),
-    store(ListNode.Cons(fin_addr(),
-    store(ListNode.Cons(decidable_rec_addr(),
-    store(ListNode.Cons(decidable_is_true_addr(),
-    store(ListNode.Cons(decidable_is_false_addr(),
-    store(ListNode.Cons(nat_le_of_ble_eq_true_addr(),
-    store(ListNode.Cons(nat_not_le_of_not_ble_eq_true_addr(),
-    store(ListNode.Cons(nat_eq_of_beq_eq_true_addr(),
-    store(ListNode.Cons(nat_ne_of_beq_eq_false_addr(),
-    store(ListNode.Cons(reduce_bool_addr(),
-    store(ListNode.Cons(reduce_nat_addr(),
-    store(ListNode.Cons(system_platform_num_bits_addr(),
-    store(ListNode.Cons(system_platform_get_num_bits_addr(),
-    store(ListNode.Cons(subtype_val_addr(),
-    store(ListNode.Cons(punit_size_of_1_addr(),
-    store(ListNode.Cons(size_of_size_of_addr(),
-    store(ListNode.Cons(punit_addr(),
-    store(ListNode.Cons(unit_addr(),
-    store(ListNode.Cons(nat_addr(),
-    store(ListNode.Cons(nat_zero_addr(),
-    store(ListNode.Cons(nat_succ_addr(),
-    store(ListNode.Cons(nat_pred_addr(),
-    store(ListNode.Cons(nat_add_addr(),
-    store(ListNode.Cons(nat_sub_addr(),
-    store(ListNode.Cons(nat_mul_addr(),
-    store(ListNode.Cons(nat_pow_addr(),
-    store(ListNode.Cons(nat_gcd_addr(),
-    store(ListNode.Cons(nat_mod_addr(),
-    store(ListNode.Cons(nat_div_addr(),
-    store(ListNode.Cons(nat_land_addr(),
-    store(ListNode.Cons(nat_lor_addr(),
-    store(ListNode.Cons(nat_xor_addr(),
-    store(ListNode.Cons(nat_shift_left_addr(),
-    store(ListNode.Cons(nat_shift_right_addr(),
-    store(ListNode.Cons(nat_beq_addr(),
-    store(ListNode.Cons(nat_ble_addr(),
-    store(ListNode.Cons(str_addr(),
-    store(ListNode.Cons(string_utf8_byte_size_addr(),
-    store(ListNode.Cons(string_back_addr(),
-    store(ListNode.Cons(string_legacy_back_addr(),
-    store(ListNode.Cons(string_to_byte_array_addr(),
-    store(ListNode.Cons(byte_array_empty_addr(),
-    store(ListNode.Cons(char_of_nat_addr(),
-    store(ListNode.Cons(char_type_addr(),
-    store(ListNode.Cons(string_of_list_addr(),
-    store(ListNode.Cons(list_nil_addr(),
-    store(ListNode.Cons(list_cons_addr(),
-    store(ListNode.Cons(bool_true_addr(),
-    store(ListNode.Cons(bool_false_addr(),
-    store(ListNode.Nil)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
-  }
-
-  fn list_addr_length(xs: List‹Addr›) -> G {
-    match load(xs) {
-      ListNode.Nil => 0,
-      ListNode.Cons(_, rest) => list_addr_length(rest) + 1,
-    }
-  }
-
-  fn list_repeat_stub(stub: &KConstantInfo, n: G) -> List‹&KConstantInfo› {
-    match n {
-      0 => store(ListNode.Nil),
-      _ => store(ListNode.Cons(stub, list_repeat_stub(stub, n - 1))),
+  fn build_recur_addrs_walk(all_members: List‹MutConst›, block_addr: Addr,
+                                 cur: List‹MutConst›, idx: G) -> List‹Addr› {
+    match load(cur) {
+      ListNode.Nil => store(ListNode.Nil),
+      ListNode.Cons(_, rest) =>
+        store(ListNode.Cons(
+          projection_addr(all_members, block_addr, idx),
+          build_recur_addrs_walk(all_members, block_addr, rest, idx + 1))),
     }
   }
 ⟧
 
 end IxVM
+
+end
diff --git a/Ix/IxVM/IxonDeserialize.lean b/Ix/IxVM/IxonDeserialize.lean
index 966924f4f..a1e1e7311 100644
--- a/Ix/IxVM/IxonDeserialize.lean
+++ b/Ix/IxVM/IxonDeserialize.lean
@@ -52,6 +52,15 @@ def ixonDeserialize := ⟦
         ([u8_from_field_unsafe(small_size), 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], s),
       _ =>
         let num_bytes = small_size + 1;
+        -- A u64 payload is at most 8 bytes. `small` is 7 bits here, so
+        -- `num_bytes` reaches 128 and `get_u64_le` would consume the
+        -- surplus and DISCARD it, silently accepting bytes no host will:
+        -- Rust rejects `len > 8`, and the Lean host folds the extra bytes
+        -- back in (its shift is mod 64), reading a different value from
+        -- the same address. Reject instead, so the accepted language
+        -- matches the format.
+        assert_eq!(u8_less_than(u8_from_field_unsafe(num_bytes), 9u8), 1,
+          "tag0: payload width exceeds 8 bytes");
         get_u64_le(s, num_bytes),
     }
   }
@@ -68,6 +77,10 @@ def ixonDeserialize := ⟦
         ((flag, [u8_from_field_unsafe(small_size), 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), s),
       _ =>
         let num_bytes = small_size + 1;
+        -- Same bound as `get_tag0`; `small` is 5 bits here, so
+        -- `num_bytes` reaches 32.
+        assert_eq!(u8_less_than(u8_from_field_unsafe(num_bytes), 9u8), 1,
+          "tag2: payload width exceeds 8 bytes");
         let (size, s2) = get_u64_le(s, num_bytes);
         ((flag, size), s2),
     }
diff --git a/Ix/IxVM/Kernel/CanonicalCheck.lean b/Ix/IxVM/Kernel/CanonicalCheck.lean
index a35a4f658..548037080 100644
--- a/Ix/IxVM/Kernel/CanonicalCheck.lean
+++ b/Ix/IxVM/Kernel/CanonicalCheck.lean
@@ -1,31 +1,37 @@
 module
 public import Ix.Aiur.Meta
 public import Ix.IxVM.KernelTypes
+public import Ix.IxVM.Ingress
 
 public section
 
 namespace IxVM
 
-/-! ## Canonical structural ordering of kernel constants
+/-! ## Canonical structural ordering of Muts block members
 
-Mirror: src/ix/kernel/canonical_check.rs.
+Mirror of Rust `crates/kernel/src/canonical_check.rs`, re-expressed
+addr-first.
 
-Provides total ordering helpers for `KLevel`, `KExpr`, `KRecRule`, and
-`KConstantInfo` so the kernel can verify that mutual blocks ship their
-members in canonical (alpha-collapsed, structurally sorted) order. Used
-by `validate_canonical_block` adjacent-pair check and by nested-aux
-ordering.
+A mutual block IS one Muts constant here, so no grouping pass is needed:
+validate that each Muts block's Indc members ship in canonical
+(alpha-collapsed, structurally sorted) order, via the same iterative
+partition refinement the Rust checker uses.
 
-Comparator returns G ∈ {0, 1, 2}: 0 = lt, 1 = eq, 2 = gt. Total order
-on closed terms (FVars unsupported — Aiur kernel never produces them).
+Comparator returns tri-valued G (0=lt, 1=eq, 2=gt) wrapped in SOrd
+(ordering, strong). Block-local refs — member projection addrs and
+their ctors' CPrj addrs, both of which EMBED the stored member index —
+compare WEAK by refinement class so the sort is blind to stored order.
+External refs compare strong by 32-byte address lex.
+
+Entry `check_canonical_block(block_addr)` is Aiur-memoized per
+block addr: called from every Induct/Rec member check, runs once.
 -/
 
 def canonicalCheck := ⟦
-  -- ============================================================================
-  -- Tri-valued ordering combinators.
-  -- 0 = lt, 1 = eq, 2 = gt.
-  -- ============================================================================
-  fn ord_cmp_g(a: G, b: G) -> G {
+  -- ==========================================================================
+  -- Tri-valued ordering combinators. 0 = lt, 1 = eq, 2 = gt.
+  -- ==========================================================================
+  fn canon_ord_cmp_g(a: G, b: G) -> G {
     match a - b {
       0 => 1,
       _ =>
@@ -36,29 +42,19 @@ def canonicalCheck := ⟦
     }
   }
 
-  -- Lexicographic chain: first non-eq wins.
-  fn ord_then(a: G, b: G) -> G {
+  fn canon_ord_then(a: G, b: G) -> G {
     match a {
       1 => b,
       _ => a,
     }
   }
 
-  -- ============================================================================
-  -- SOrd: (ordering, strong) tuple. Mirror of Rust's SOrd. ordering ∈ {0=lt,
-  -- 1=eq, 2=gt}; strong ∈ {0=weak, 1=strong}. compare_kexpr_ctx returns SOrd.
-  -- Block-local Const refs (resolved via KMutCtx) yield WEAK SOrd; everything
-  -- else is STRONG. validate_canonical_block_single_pass accepts strong-Less
-  -- directly, falls back to validate_by_refinement on weak-Less.
-  -- ============================================================================
-  fn sord_lt_strong() -> (G, G) { (0, 1) }
-  fn sord_lt_weak() -> (G, G)   { (0, 0) }
-  fn sord_eq_strong() -> (G, G) { (1, 1) }
-  fn sord_eq_weak() -> (G, G)   { (1, 0) }
-  fn sord_gt_strong() -> (G, G) { (2, 1) }
+  -- SOrd = (ordering, strong). strong ∈ {0=weak, 1=strong}.
+  fn canon_sord_lt_strong() -> (G, G) { (0, 1) }
+  fn canon_sord_eq_strong() -> (G, G) { (1, 1) }
+  fn canon_sord_gt_strong() -> (G, G) { (2, 1) }
 
-  -- Lex chain on SOrd: if a is Equal, take b's ordering and strong=a.strong*b.strong.
-  fn sord_then(a: (G, G), b: (G, G)) -> (G, G) {
+  fn canon_sord_then(a: (G, G), b: (G, G)) -> (G, G) {
     match a {
       (1, sa) =>
         match b {
@@ -68,96 +64,89 @@ def canonicalCheck := ⟦
     }
   }
 
-  -- Wrap a tri-valued G ord as strong SOrd.
-  fn sord_of_g(o: G) -> (G, G) { (o, 1) }
+  fn canon_sord_of_g(o: G) -> (G, G) { (o, 1) }
 
-  -- KMutCtx mirror: a list of (kernel position, class index) pairs.
-  -- Mirror: canonical_check.rs:100-118 KMutCtx::from_id_classes — every
-  -- member of class j maps to j (same-class members share ONE index, so
-  -- refs to them compare weak-Equal, never a position-derived tiebreak),
-  -- and every ctor of an Indc member maps to i + cidx where i starts at
-  -- |classes| and advances by each class's max ctor count.
-  -- ctx_class_idx: returns 1+class_idx if `idx` ∈ ctx, else 0.
-  fn ctx_class_idx(idx: G, ctx: List‹(G, G)›) -> G {
+  -- ==========================================================================
+  -- 32-byte address lex compare (mirror addr_cmp — 4-byte big-endian
+  -- chunks; packing preserves byte-lex order).
+  -- ==========================================================================
+  fn canon_addr_cmp(x: Addr, y: Addr) -> G {
+    let xa = load(x);
+    let ya = load(y);
+    canon_ord_then(canon_addr_chunk(to_field(xa[0]), to_field(xa[1]), to_field(xa[2]), to_field(xa[3]),
+                                to_field(ya[0]), to_field(ya[1]), to_field(ya[2]), to_field(ya[3])),
+      canon_ord_then(canon_addr_chunk(to_field(xa[4]), to_field(xa[5]), to_field(xa[6]), to_field(xa[7]),
+                                  to_field(ya[4]), to_field(ya[5]), to_field(ya[6]), to_field(ya[7])),
+        canon_ord_then(canon_addr_chunk(to_field(xa[8]), to_field(xa[9]), to_field(xa[10]), to_field(xa[11]),
+                                    to_field(ya[8]), to_field(ya[9]), to_field(ya[10]), to_field(ya[11])),
+          canon_ord_then(canon_addr_chunk(to_field(xa[12]), to_field(xa[13]), to_field(xa[14]), to_field(xa[15]),
+                                      to_field(ya[12]), to_field(ya[13]), to_field(ya[14]), to_field(ya[15])),
+            canon_ord_then(canon_addr_chunk(to_field(xa[16]), to_field(xa[17]), to_field(xa[18]), to_field(xa[19]),
+                                        to_field(ya[16]), to_field(ya[17]), to_field(ya[18]), to_field(ya[19])),
+              canon_ord_then(canon_addr_chunk(to_field(xa[20]), to_field(xa[21]), to_field(xa[22]), to_field(xa[23]),
+                                          to_field(ya[20]), to_field(ya[21]), to_field(ya[22]), to_field(ya[23])),
+                canon_ord_then(canon_addr_chunk(to_field(xa[24]), to_field(xa[25]), to_field(xa[26]), to_field(xa[27]),
+                                            to_field(ya[24]), to_field(ya[25]), to_field(ya[26]), to_field(ya[27])),
+                              canon_addr_chunk(to_field(xa[28]), to_field(xa[29]), to_field(xa[30]), to_field(xa[31]),
+                                             to_field(ya[28]), to_field(ya[29]), to_field(ya[30]), to_field(ya[31])))))))))
+  }
+
+  fn canon_addr_chunk(x0: G, x1: G, x2: G, x3: G,
+                    y0: G, y1: G, y2: G, y3: G) -> G {
+    let xv = x0 * 16777216 + x1 * 65536 + x2 * 256 + x3;
+    let yv = y0 * 16777216 + y1 * 65536 + y2 * 256 + y3;
+    canon_ord_cmp_g(xv, yv)
+  }
+
+  -- ==========================================================================
+  -- KMutCtx: addr-keyed. Entries map block-local addrs (member proj
+  -- addrs + ctor CPrj addrs) to a class index. Mirror ctx over
+  -- ingress positions (canonical_check.rs KMutCtx::from_id_classes).
+  -- Returns 1+class if found, 0 otherwise.
+  -- ==========================================================================
+  fn canon_ctx_class_idx(a: Addr, ctx: List‹(Addr, G)›) -> G {
     match load(ctx) {
       ListNode.Nil => 0,
       ListNode.Cons(entry, rest) =>
         match entry {
-          (pos, j) =>
-            match pos - idx {
-              0 => 1 + j,
-              _ => ctx_class_idx(idx, rest),
+          (ea, j) =>
+            match address_eq(a, ea) {
+              1 => 1 + j,
+              _ => canon_ctx_class_idx(a, rest),
             },
         },
     }
   }
 
-  -- Lexicographic compare of two 32-byte addresses (mirror: Rust
-  -- `Address`'s derived `Ord`). Packs 4 bytes big-endian per chunk so
-  -- 8 u32 comparisons decide; packing preserves byte-lex order.
-  fn addr_cmp(x: Addr, y: Addr) -> G {
-    let xa = load(x);
-    let ya = load(y);
-    ord_then(addr_cmp_chunk(to_field(xa[0]), to_field(xa[1]), to_field(xa[2]), to_field(xa[3]),
-                            to_field(ya[0]), to_field(ya[1]), to_field(ya[2]), to_field(ya[3])),
-      ord_then(addr_cmp_chunk(to_field(xa[4]), to_field(xa[5]), to_field(xa[6]), to_field(xa[7]),
-                              to_field(ya[4]), to_field(ya[5]), to_field(ya[6]), to_field(ya[7])),
-        ord_then(addr_cmp_chunk(to_field(xa[8]), to_field(xa[9]), to_field(xa[10]), to_field(xa[11]),
-                                to_field(ya[8]), to_field(ya[9]), to_field(ya[10]), to_field(ya[11])),
-          ord_then(addr_cmp_chunk(to_field(xa[12]), to_field(xa[13]), to_field(xa[14]), to_field(xa[15]),
-                                  to_field(ya[12]), to_field(ya[13]), to_field(ya[14]), to_field(ya[15])),
-            ord_then(addr_cmp_chunk(to_field(xa[16]), to_field(xa[17]), to_field(xa[18]), to_field(xa[19]),
-                                    to_field(ya[16]), to_field(ya[17]), to_field(ya[18]), to_field(ya[19])),
-              ord_then(addr_cmp_chunk(to_field(xa[20]), to_field(xa[21]), to_field(xa[22]), to_field(xa[23]),
-                                      to_field(ya[20]), to_field(ya[21]), to_field(ya[22]), to_field(ya[23])),
-                ord_then(addr_cmp_chunk(to_field(xa[24]), to_field(xa[25]), to_field(xa[26]), to_field(xa[27]),
-                                        to_field(ya[24]), to_field(ya[25]), to_field(ya[26]), to_field(ya[27])),
-                          addr_cmp_chunk(to_field(xa[28]), to_field(xa[29]), to_field(xa[30]), to_field(xa[31]),
-                                         to_field(ya[28]), to_field(ya[29]), to_field(ya[30]), to_field(ya[31])))))))))
-  }
-
-  fn addr_cmp_chunk(x0: G, x1: G, x2: G, x3: G,
-                    y0: G, y1: G, y2: G, y3: G) -> G {
-    let xv = x0 * 16777216 + x1 * 65536 + x2 * 256 + x3;
-    let yv = y0 * 16777216 + y1 * 65536 + y2 * 256 + y3;
-    ord_cmp_g(xv, yv)
-  }
-
-  -- Compare two Const position refs under a KMutCtx.
-  -- Mirror: canonical_check.rs:213-222 — same ref ⇒ Equal strong; both
-  -- block-local ⇒ weak cmp of class indices (same class ⇒ weak Equal);
-  -- one local ⇒ local < external, strong; both external ⇒ strong cmp of
-  -- ADDRESSES (kernel analogue of compare_external_refs — NOT ingress
-  -- positions, which have no canonical order).
-  fn ctx_cmp_idx(xid: G, yid: G, ctx: List‹(G, G)›, addrs: List‹Addr›) -> (G, G) {
-    match xid - yid {
-      0 => sord_eq_strong(),
+  -- Compare two Const addr refs under ctx (mirror ctx_cmp_idx):
+  -- same addr ⇒ Equal strong; both block-local ⇒ WEAK cmp of class
+  -- indices; one local ⇒ local < external, strong; both external ⇒
+  -- strong 32-byte addr cmp.
+  fn canon_ctx_cmp_addr(x: Addr, y: Addr, ctx: List‹(Addr, G)›) -> (G, G) {
+    match address_eq(x, y) {
+      1 => canon_sord_eq_strong(),
       _ =>
-        let mx = ctx_class_idx(xid, ctx);
-        let my = ctx_class_idx(yid, ctx);
+        let mx = canon_ctx_class_idx(x, ctx);
+        let my = canon_ctx_class_idx(y, ctx);
         match mx {
           0 =>
             match my {
-              0 => sord_of_g(addr_cmp(list_lookup(addrs, xid),
-                                      list_lookup(addrs, yid))),
-              _ => sord_gt_strong(),
+              0 => canon_sord_of_g(canon_addr_cmp(x, y)),
+              _ => canon_sord_gt_strong(),
             },
           _ =>
             match my {
-              0 => sord_lt_strong(),
-              _ => (ord_cmp_g(mx, my), 0),
+              0 => canon_sord_lt_strong(),
+              _ => (canon_ord_cmp_g(mx, my), 0),
             },
         },
     }
   }
 
-  -- ============================================================================
-  -- compare_kuniv
-  --
-  -- Mirror: canonical_check.rs:130-154. Variant order Zero < Succ < Max <
-  -- IMax < Param.
-  -- ============================================================================
-  fn compare_kuniv(x: KLevel, y: KLevel) -> G {
+  -- ==========================================================================
+  -- compare_kuniv. Variant order Zero < Succ < Max < IMax < Param.
+  -- ==========================================================================
+  fn canon_cmp_kuniv(x: KLevel, y: KLevel) -> G {
     match load(x) {
       KLevelNode.Zero =>
         match load(y) {
@@ -167,7 +156,7 @@ def canonicalCheck := ⟦
       KLevelNode.Succ(xa) =>
         match load(y) {
           KLevelNode.Zero => 2,
-          KLevelNode.Succ(ya) => compare_kuniv(xa, ya),
+          KLevelNode.Succ(ya) => canon_cmp_kuniv(xa, ya),
           _ => 0,
         },
       KLevelNode.Max(xl, xr) =>
@@ -175,7 +164,7 @@ def canonicalCheck := ⟦
           KLevelNode.Zero => 2,
           KLevelNode.Succ(_) => 2,
           KLevelNode.Max(yl, yr) =>
-            ord_then(compare_kuniv(xl, yl), compare_kuniv(xr, yr)),
+            canon_ord_then(canon_cmp_kuniv(xl, yl), canon_cmp_kuniv(xr, yr)),
           _ => 0,
         },
       KLevelNode.IMax(xl, xr) =>
@@ -184,18 +173,18 @@ def canonicalCheck := ⟦
           KLevelNode.Succ(_) => 2,
           KLevelNode.Max(_, _) => 2,
           KLevelNode.IMax(yl, yr) =>
-            ord_then(compare_kuniv(xl, yl), compare_kuniv(xr, yr)),
+            canon_ord_then(canon_cmp_kuniv(xl, yl), canon_cmp_kuniv(xr, yr)),
           KLevelNode.Param(_) => 0,
         },
       KLevelNode.Param(xi) =>
         match load(y) {
-          KLevelNode.Param(yi) => ord_cmp_g(xi, yi),
+          KLevelNode.Param(yi) => canon_ord_cmp_g(xi, yi),
           _ => 2,
         },
     }
   }
 
-  fn compare_kuniv_list(xs: List‹KLevel›, ys: List‹KLevel›) -> G {
+  fn canon_cmp_kuniv_list(xs: List‹KLevel›, ys: List‹KLevel›) -> G {
     match load(xs) {
       ListNode.Nil =>
         match load(ys) {
@@ -206,276 +195,65 @@ def canonicalCheck := ⟦
         match load(ys) {
           ListNode.Nil => 2,
           ListNode.Cons(yh, yt) =>
-            ord_then(compare_kuniv(xh, yh), compare_kuniv_list(xt, yt)),
-        },
-    }
-  }
-
-  -- SOrd-returning variant; universes are structural so always strong.
-  fn compare_kuniv_list_sord(xs: List‹KLevel›, ys: List‹KLevel›) -> (G, G) {
-    sord_of_g(compare_kuniv_list(xs, ys))
-  }
-
-  -- ============================================================================
-  -- compare_kexpr
-  --
-  -- Mirror: canonical_check.rs:167-275. Variant order BVar < Srt < Const <
-  -- App < Lam < Forall < Let < Lit < Proj. Alpha-blind: binders' types
-  -- compared, then bodies. (No fvars; Aiur kernel uses de Bruijn indices.)
-  -- ============================================================================
-  fn compare_kexpr(x: KExpr, y: KExpr) -> G {
-    match ptr_val(x) - ptr_val(y) {
-      0 => 1,
-      _ => compare_kexpr_node(load(x), load(y)),
-    }
-  }
-
-  fn compare_kexpr_node(x: KExprNode, y: KExprNode) -> G {
-    match x {
-      KExprNode.BVar(xi) =>
-        match y {
-          KExprNode.BVar(yi) => ord_cmp_g(xi, yi),
-          _ => 0,
-        },
-      KExprNode.Srt(xu) =>
-        match y {
-          KExprNode.BVar(_) => 2,
-          KExprNode.Srt(yu) => compare_kuniv(xu, yu),
-          _ => 0,
-        },
-      KExprNode.Const(xid, xls) =>
-        match y {
-          KExprNode.BVar(_) => 2,
-          KExprNode.Srt(_) => 2,
-          KExprNode.Const(yid, yls) =>
-            -- Mirror: canonical_check.rs:204-223 — levels first, then ref.
-            -- (Position stands in for the address here; fine for the
-            -- equality-only callers of this ctx-less comparator.)
-            ord_then(compare_kuniv_list(xls, yls), ord_cmp_g(xid, yid)),
-          _ => 0,
-        },
-      KExprNode.App(xf, xa) =>
-        match y {
-          KExprNode.BVar(_) => 2,
-          KExprNode.Srt(_) => 2,
-          KExprNode.Const(_, _) => 2,
-          KExprNode.App(yf, ya) =>
-            ord_then(compare_kexpr(xf, yf), compare_kexpr(xa, ya)),
-          _ => 0,
-        },
-      KExprNode.Lam(xt, xb) =>
-        match y {
-          KExprNode.BVar(_) => 2,
-          KExprNode.Srt(_) => 2,
-          KExprNode.Const(_, _) => 2,
-          KExprNode.App(_, _) => 2,
-          KExprNode.Lam(yt, yb) =>
-            ord_then(compare_kexpr(xt, yt), compare_kexpr(xb, yb)),
-          _ => 0,
-        },
-      KExprNode.Forall(xt, xb) =>
-        match y {
-          KExprNode.BVar(_) => 2,
-          KExprNode.Srt(_) => 2,
-          KExprNode.Const(_, _) => 2,
-          KExprNode.App(_, _) => 2,
-          KExprNode.Lam(_, _) => 2,
-          KExprNode.Forall(yt, yb) =>
-            ord_then(compare_kexpr(xt, yt), compare_kexpr(xb, yb)),
-          _ => 0,
-        },
-      KExprNode.Let(xt, xv, xb) =>
-        match y {
-          KExprNode.BVar(_) => 2,
-          KExprNode.Srt(_) => 2,
-          KExprNode.Const(_, _) => 2,
-          KExprNode.App(_, _) => 2,
-          KExprNode.Lam(_, _) => 2,
-          KExprNode.Forall(_, _) => 2,
-          KExprNode.Let(yt, yv, yb) =>
-            ord_then(compare_kexpr(xt, yt),
-              ord_then(compare_kexpr(xv, yv), compare_kexpr(xb, yb))),
-          _ => 0,
-        },
-      KExprNode.Lit(xl) =>
-        match y {
-          KExprNode.Proj(_, _, _) => 0,
-          KExprNode.Lit(yl) => compare_kliteral(xl, yl),
-          _ => 2,
-        },
-      KExprNode.Proj(xt, xf, xe) =>
-        match y {
-          KExprNode.Proj(yt, yf, ye) =>
-            ord_then(ord_cmp_g(xt, yt),
-              ord_then(ord_cmp_g(xf, yf), compare_kexpr(xe, ye))),
-          _ => 2,
+            canon_ord_then(canon_cmp_kuniv(xh, yh), canon_cmp_kuniv_list(xt, yt)),
         },
     }
   }
 
-  -- ============================================================================
-  -- compare_kexpr_ctx: SOrd-returning, KMutCtx-aware variant.
-  -- Mirror: canonical_check.rs:167-280 compare_kexpr.
-  -- Const + Proj head ref use ctx_cmp_idx to resolve block-local refs.
-  -- Other arms thread ctx into recursive calls.
-  -- ============================================================================
-  fn compare_kexpr_ctx(x: KExpr, y: KExpr, ctx: List‹(G, G)›,
-                       addrs: List‹Addr›) -> (G, G) {
-    match ptr_val(x) - ptr_val(y) {
-      0 => sord_eq_strong(),
-      _ => compare_kexpr_node_ctx(load(x), load(y), ctx, addrs),
-    }
-  }
-
-  fn compare_kexpr_node_ctx(x: KExprNode, y: KExprNode, ctx: List‹(G, G)›,
-                            addrs: List‹Addr›) -> (G, G) {
-    match x {
-      KExprNode.BVar(xi) =>
-        match y {
-          KExprNode.BVar(yi) => sord_of_g(ord_cmp_g(xi, yi)),
-          _ => sord_lt_strong(),
-        },
-      KExprNode.Srt(xu) =>
-        match y {
-          KExprNode.BVar(_) => sord_gt_strong(),
-          KExprNode.Srt(yu) => sord_of_g(compare_kuniv(xu, yu)),
-          _ => sord_lt_strong(),
-        },
-      KExprNode.Const(xid, xls) =>
-        match y {
-          KExprNode.BVar(_) => sord_gt_strong(),
-          KExprNode.Srt(_) => sord_gt_strong(),
-          KExprNode.Const(yid, yls) =>
-            sord_then(compare_kuniv_list_sord(xls, yls),
-              ctx_cmp_idx(xid, yid, ctx, addrs)),
-          _ => sord_lt_strong(),
-        },
-      KExprNode.App(xf, xa) =>
-        match y {
-          KExprNode.BVar(_) => sord_gt_strong(),
-          KExprNode.Srt(_) => sord_gt_strong(),
-          KExprNode.Const(_, _) => sord_gt_strong(),
-          KExprNode.App(yf, ya) =>
-            sord_then(compare_kexpr_ctx(xf, yf, ctx, addrs),
-                       compare_kexpr_ctx(xa, ya, ctx, addrs)),
-          _ => sord_lt_strong(),
-        },
-      KExprNode.Lam(xt, xb) =>
-        match y {
-          KExprNode.BVar(_) => sord_gt_strong(),
-          KExprNode.Srt(_) => sord_gt_strong(),
-          KExprNode.Const(_, _) => sord_gt_strong(),
-          KExprNode.App(_, _) => sord_gt_strong(),
-          KExprNode.Lam(yt, yb) =>
-            sord_then(compare_kexpr_ctx(xt, yt, ctx, addrs),
-                       compare_kexpr_ctx(xb, yb, ctx, addrs)),
-          _ => sord_lt_strong(),
-        },
-      KExprNode.Forall(xt, xb) =>
-        match y {
-          KExprNode.BVar(_) => sord_gt_strong(),
-          KExprNode.Srt(_) => sord_gt_strong(),
-          KExprNode.Const(_, _) => sord_gt_strong(),
-          KExprNode.App(_, _) => sord_gt_strong(),
-          KExprNode.Lam(_, _) => sord_gt_strong(),
-          KExprNode.Forall(yt, yb) =>
-            sord_then(compare_kexpr_ctx(xt, yt, ctx, addrs),
-                       compare_kexpr_ctx(xb, yb, ctx, addrs)),
-          _ => sord_lt_strong(),
-        },
-      KExprNode.Let(xt, xv, xb) =>
-        match y {
-          KExprNode.BVar(_) => sord_gt_strong(),
-          KExprNode.Srt(_) => sord_gt_strong(),
-          KExprNode.Const(_, _) => sord_gt_strong(),
-          KExprNode.App(_, _) => sord_gt_strong(),
-          KExprNode.Lam(_, _) => sord_gt_strong(),
-          KExprNode.Forall(_, _) => sord_gt_strong(),
-          KExprNode.Let(yt, yv, yb) =>
-            sord_then(compare_kexpr_ctx(xt, yt, ctx, addrs),
-              sord_then(compare_kexpr_ctx(xv, yv, ctx, addrs),
-                         compare_kexpr_ctx(xb, yb, ctx, addrs))),
-          _ => sord_lt_strong(),
-        },
-      KExprNode.Lit(xl) =>
-        match y {
-          KExprNode.Proj(_, _, _) => sord_lt_strong(),
-          KExprNode.Lit(yl) => sord_of_g(compare_kliteral(xl, yl)),
-          _ => sord_gt_strong(),
-        },
-      KExprNode.Proj(xt, xf, xe) =>
-        match y {
-          KExprNode.Proj(yt, yf, ye) =>
-            sord_then(ctx_cmp_idx(xt, yt, ctx, addrs),
-              sord_then(sord_of_g(ord_cmp_g(xf, yf)),
-                         compare_kexpr_ctx(xe, ye, ctx, addrs))),
-          _ => sord_gt_strong(),
-        },
-    }
-  }
-
-  -- KLiteral order: Nat < Str. Within each, lex on contents.
-  fn compare_kliteral(x: KLiteral, y: KLiteral) -> G {
+  -- ==========================================================================
+  -- Literals: Nat < Str; lex within.
+  -- ==========================================================================
+  fn canon_cmp_kliteral(x: KLiteral, y: KLiteral) -> G {
     match x {
       KLiteral.Nat(xn) =>
         match y {
-          KLiteral.Nat(yn) => compare_klimbs(xn, yn),
+          KLiteral.Nat(yn) => canon_cmp_klimbs(xn, yn),
           KLiteral.Str(_) => 0,
         },
       KLiteral.Str(xb) =>
         match y {
           KLiteral.Nat(_) => 2,
-          KLiteral.Str(yb) => compare_byte_stream(xb, yb),
+          KLiteral.Str(yb) => canon_cmp_bytes(xb, yb),
         },
     }
   }
 
-  -- Compare KLimbs little-endian. Higher limbs more significant; longer
-  -- list = larger value. Walk from tail (most significant); with same
-  -- length, lex by limb. Simpler: post-normalize, compare lengths first,
-  -- then lex the equal-length tails with most-significant first.
-  fn compare_klimbs(x: KLimbs, y: KLimbs) -> G {
+  fn canon_cmp_klimbs(x: KLimbs, y: KLimbs) -> G {
     let xn = klimbs_normalize(x);
     let yn = klimbs_normalize(y);
-    let lx = list_length(xn);
-    let ly = list_length(yn);
-    let len_ord = ord_cmp_g(lx, ly);
+    let len_ord = canon_ord_cmp_g(list_length(xn), list_length(yn));
     match len_ord {
-      1 => compare_klimbs_tail(xn, yn),
+      1 => canon_cmp_klimbs_tail(xn, yn),
       _ => len_ord,
     }
   }
 
-  -- Compare equal-length KLimbs lex from MOST significant. We have them
-  -- LE, so reverse-walk: recurse first, compare current after.
-  fn compare_klimbs_tail(x: KLimbs, y: KLimbs) -> G {
+  fn canon_cmp_klimbs_tail(x: KLimbs, y: KLimbs) -> G {
     match load(x) {
       ListNode.Nil => 1,
       ListNode.Cons(xh, xt) =>
         match load(y) {
           ListNode.Cons(yh, yt) =>
-            let tail_ord = compare_klimbs_tail(xt, yt);
-            ord_then(tail_ord, compare_u64_lex(xh, yh)),
+            let tail_ord = canon_cmp_klimbs_tail(xt, yt);
+            canon_ord_then(tail_ord, canon_cmp_u64_lex(xh, yh)),
         },
     }
   }
 
-  -- Compare two u64 limbs as integers (little-endian byte order).
-  fn compare_u64_lex(a: U64, b: U64) -> G {
+  fn canon_cmp_u64_lex(a: U64, b: U64) -> G {
     let [a0, a1, a2, a3, a4, a5, a6, a7] = a;
     let [b0, b1, b2, b3, b4, b5, b6, b7] = b;
-    -- Most significant byte first.
-    ord_then(ord_cmp_g(to_field(a7), to_field(b7)),
-      ord_then(ord_cmp_g(to_field(a6), to_field(b6)),
-        ord_then(ord_cmp_g(to_field(a5), to_field(b5)),
-          ord_then(ord_cmp_g(to_field(a4), to_field(b4)),
-            ord_then(ord_cmp_g(to_field(a3), to_field(b3)),
-              ord_then(ord_cmp_g(to_field(a2), to_field(b2)),
-                ord_then(ord_cmp_g(to_field(a1), to_field(b1)),
-                  ord_cmp_g(to_field(a0), to_field(b0)))))))))
+    canon_ord_then(canon_ord_cmp_g(to_field(a7), to_field(b7)),
+      canon_ord_then(canon_ord_cmp_g(to_field(a6), to_field(b6)),
+        canon_ord_then(canon_ord_cmp_g(to_field(a5), to_field(b5)),
+          canon_ord_then(canon_ord_cmp_g(to_field(a4), to_field(b4)),
+            canon_ord_then(canon_ord_cmp_g(to_field(a3), to_field(b3)),
+              canon_ord_then(canon_ord_cmp_g(to_field(a2), to_field(b2)),
+                canon_ord_then(canon_ord_cmp_g(to_field(a1), to_field(b1)),
+                  canon_ord_cmp_g(to_field(a0), to_field(b0)))))))))
   }
 
-  fn compare_byte_stream(x: ByteStream, y: ByteStream) -> G {
+  fn canon_cmp_bytes(x: ByteStream, y: ByteStream) -> G {
     match load(x) {
       ListNode.Nil =>
         match load(y) {
@@ -486,575 +264,315 @@ def canonicalCheck := ⟦
         match load(y) {
           ListNode.Nil => 2,
           ListNode.Cons(yh, yt) =>
-            ord_then(ord_cmp_g(to_field(xh), to_field(yh)), compare_byte_stream(xt, yt)),
+            canon_ord_then(canon_ord_cmp_g(to_field(xh), to_field(yh)),
+                         canon_cmp_bytes(xt, yt)),
         },
     }
   }
 
-  -- ============================================================================
-  -- compare_krec_rule
-  --
-  -- Mirror: canonical_check.rs:280-298. Triple lex.
-  -- ============================================================================
-  fn compare_krec_rule(x: KRecRule, y: KRecRule) -> G {
-    match x {
-      KRecRule.Mk(_xc, xn, xr) =>
-        match y {
-          KRecRule.Mk(_yc, yn, yr) =>
-            -- Mirror: canonical_check.rs:280-289 — (fields, rhs) ONLY. The
-            -- leading global ctor idx is an ingress artifact with no
-            -- canonical meaning; comparing it would order by discovery.
-            ord_then(ord_cmp_g(xn, yn), compare_kexpr(xr, yr)),
-        },
+  -- ==========================================================================
+  -- compare_kexpr_ctx: SOrd, KMutCtx-aware. Variant order BVar < Srt <
+  -- Const < App < Lam < Forall < Let < Lit < Proj. Const + Proj struct
+  -- refs resolve block-local addrs weak via canon_ctx_cmp_addr.
+  -- ==========================================================================
+  fn canon_cmp_kexpr_ctx(x: KExpr, y: KExpr, ctx: List‹(Addr, G)›) -> (G, G) {
+    match ptr_val(x) - ptr_val(y) {
+      0 => canon_sord_eq_strong(),
+      _ => canon_cmp_kexpr_node_ctx(load(x), load(y), ctx),
     }
   }
 
-  fn compare_krec_rule_list(xs: List‹KRecRule›, ys: List‹KRecRule›) -> G {
-    match load(xs) {
-      ListNode.Nil =>
-        match load(ys) {
-          ListNode.Nil => 1,
-          _ => 0,
+  fn canon_cmp_kexpr_node_ctx(x: KExprNode, y: KExprNode,
+                            ctx: List‹(Addr, G)›) -> (G, G) {
+    match x {
+      KExprNode.BVar(xi) =>
+        match y {
+          KExprNode.BVar(yi) => canon_sord_of_g(canon_ord_cmp_g(xi, yi)),
+          _ => canon_sord_lt_strong(),
         },
-      ListNode.Cons(xh, xt) =>
-        match load(ys) {
-          ListNode.Nil => 2,
-          ListNode.Cons(yh, yt) =>
-            ord_then(compare_krec_rule(xh, yh), compare_krec_rule_list(xt, yt)),
+      KExprNode.Srt(xu) =>
+        match y {
+          KExprNode.BVar(_) => canon_sord_gt_strong(),
+          KExprNode.Srt(yu) => canon_sord_of_g(canon_cmp_kuniv(xu, yu)),
+          _ => canon_sord_lt_strong(),
+        },
+      KExprNode.Const(xa, xls) =>
+        match y {
+          KExprNode.BVar(_) => canon_sord_gt_strong(),
+          KExprNode.Srt(_) => canon_sord_gt_strong(),
+          KExprNode.Const(ya, yls) =>
+            canon_sord_then(canon_sord_of_g(canon_cmp_kuniv_list(xls, yls)),
+              canon_ctx_cmp_addr(xa, ya, ctx)),
+          _ => canon_sord_lt_strong(),
+        },
+      KExprNode.App(xf, xa) =>
+        match y {
+          KExprNode.BVar(_) => canon_sord_gt_strong(),
+          KExprNode.Srt(_) => canon_sord_gt_strong(),
+          KExprNode.Const(_, _) => canon_sord_gt_strong(),
+          KExprNode.App(yf, ya) =>
+            canon_sord_then(canon_cmp_kexpr_ctx(xf, yf, ctx),
+                          canon_cmp_kexpr_ctx(xa, ya, ctx)),
+          _ => canon_sord_lt_strong(),
+        },
+      KExprNode.Lam(xt, xb) =>
+        match y {
+          KExprNode.BVar(_) => canon_sord_gt_strong(),
+          KExprNode.Srt(_) => canon_sord_gt_strong(),
+          KExprNode.Const(_, _) => canon_sord_gt_strong(),
+          KExprNode.App(_, _) => canon_sord_gt_strong(),
+          KExprNode.Lam(yt, yb) =>
+            canon_sord_then(canon_cmp_kexpr_ctx(xt, yt, ctx),
+                          canon_cmp_kexpr_ctx(xb, yb, ctx)),
+          _ => canon_sord_lt_strong(),
+        },
+      KExprNode.Forall(xt, xb) =>
+        match y {
+          KExprNode.BVar(_) => canon_sord_gt_strong(),
+          KExprNode.Srt(_) => canon_sord_gt_strong(),
+          KExprNode.Const(_, _) => canon_sord_gt_strong(),
+          KExprNode.App(_, _) => canon_sord_gt_strong(),
+          KExprNode.Lam(_, _) => canon_sord_gt_strong(),
+          KExprNode.Forall(yt, yb) =>
+            canon_sord_then(canon_cmp_kexpr_ctx(xt, yt, ctx),
+                          canon_cmp_kexpr_ctx(xb, yb, ctx)),
+          _ => canon_sord_lt_strong(),
+        },
+      KExprNode.Let(xt, xv, xb) =>
+        match y {
+          KExprNode.BVar(_) => canon_sord_gt_strong(),
+          KExprNode.Srt(_) => canon_sord_gt_strong(),
+          KExprNode.Const(_, _) => canon_sord_gt_strong(),
+          KExprNode.App(_, _) => canon_sord_gt_strong(),
+          KExprNode.Lam(_, _) => canon_sord_gt_strong(),
+          KExprNode.Forall(_, _) => canon_sord_gt_strong(),
+          KExprNode.Let(yt, yv, yb) =>
+            canon_sord_then(canon_cmp_kexpr_ctx(xt, yt, ctx),
+              canon_sord_then(canon_cmp_kexpr_ctx(xv, yv, ctx),
+                            canon_cmp_kexpr_ctx(xb, yb, ctx))),
+          _ => canon_sord_lt_strong(),
+        },
+      KExprNode.Lit(xl) =>
+        match y {
+          KExprNode.Proj(_, _, _) => canon_sord_lt_strong(),
+          KExprNode.Lit(yl) => canon_sord_of_g(canon_cmp_kliteral(xl, yl)),
+          _ => canon_sord_gt_strong(),
+        },
+      KExprNode.Proj(xs, xf, xe) =>
+        match y {
+          KExprNode.Proj(ys, yf, ye) =>
+            canon_sord_then(canon_ctx_cmp_addr(xs, ys, ctx),
+              canon_sord_then(canon_sord_of_g(canon_ord_cmp_g(xf, yf)),
+                            canon_cmp_kexpr_ctx(xe, ye, ctx))),
+          _ => canon_sord_gt_strong(),
         },
     }
   }
 
-  -- ctx-aware variant: SOrd-returning, threads ctx into compare_kexpr.
-  -- Mirror: canonical_check.rs:280-289 — (fields, rhs) ONLY; the leading
-  -- global ctor idx is an ingress artifact (see compare_krec_rule).
-  fn compare_krec_rule_ctx(x: KRecRule, y: KRecRule, ctx: List‹(G, G)›,
-                           addrs: List‹Addr›) -> (G, G) {
+  -- ==========================================================================
+  -- Rec rules: (fields, rhs) only — the leading ctor idx is excluded
+  -- from the comparator key (mirror / canonical_check.rs:280-289).
+  -- ==========================================================================
+  fn canon_cmp_krec_rule_ctx(x: KRecRule, y: KRecRule,
+                           ctx: List‹(Addr, G)›) -> (G, G) {
     match x {
       KRecRule.Mk(_xc, xn, xr) =>
         match y {
           KRecRule.Mk(_yc, yn, yr) =>
-            sord_then(sord_of_g(ord_cmp_g(xn, yn)),
-                       compare_kexpr_ctx(xr, yr, ctx, addrs)),
+            canon_sord_then(canon_sord_of_g(canon_ord_cmp_g(xn, yn)),
+                          canon_cmp_kexpr_ctx(xr, yr, ctx)),
         },
     }
   }
 
-  fn compare_krec_rule_list_ctx(xs: List‹KRecRule›, ys: List‹KRecRule›,
-                                 ctx: List‹(G, G)›, addrs: List‹Addr›) -> (G, G) {
+  fn canon_cmp_krec_rule_list_ctx(xs: List‹KRecRule›, ys: List‹KRecRule›,
+                                ctx: List‹(Addr, G)›) -> (G, G) {
     match load(xs) {
       ListNode.Nil =>
         match load(ys) {
-          ListNode.Nil => sord_eq_strong(),
-          _ => sord_lt_strong(),
+          ListNode.Nil => canon_sord_eq_strong(),
+          _ => canon_sord_lt_strong(),
         },
       ListNode.Cons(xh, xt) =>
         match load(ys) {
-          ListNode.Nil => sord_gt_strong(),
+          ListNode.Nil => canon_sord_gt_strong(),
           ListNode.Cons(yh, yt) =>
-            sord_then(compare_krec_rule_ctx(xh, yh, ctx, addrs),
-                       compare_krec_rule_list_ctx(xt, yt, ctx, addrs)),
+            canon_sord_then(canon_cmp_krec_rule_ctx(xh, yh, ctx),
+                          canon_cmp_krec_rule_list_ctx(xt, yt, ctx)),
         },
     }
   }
 
-  fn compare_g_list(xs: List‹G›, ys: List‹G›) -> G {
-    match load(xs) {
-      ListNode.Nil =>
-        match load(ys) {
-          ListNode.Nil => 1,
-          _ => 0,
-        },
-      ListNode.Cons(xh, xt) =>
-        match load(ys) {
-          ListNode.Nil => 2,
-          ListNode.Cons(yh, yt) =>
-            ord_then(ord_cmp_g(xh, yh), compare_g_list(xt, yt)),
-        },
-    }
-  }
-
-  -- ============================================================================
-  -- compare_kconst
-  --
-  -- Mirror: canonical_check.rs:440-543 + kind ordinals. Variant order:
-  -- Defn=0, Thm=1, Opaque=2, Quot=3, Axiom=4, Induct=5, Ctor=6, Rec=7.
-  -- Tiebreak: per-variant payload comparison.
-  -- ============================================================================
-  -- Mirror: src/ix/kernel/canonical_check.rs:440-449 kconst_kind_ord.
-  -- Defn=0, Indc=1, Recr=2, Ctor=3, Axio=4, Quot=5. (Thm/Opaque are
-  -- Defn-flavored; reuse Defn's slot ordering — only Defn/Indc/Recr are
-  -- block-eligible per Rust comment.)
-  fn kconst_kind_ord(c: KConstantInfo) -> G {
+  -- ==========================================================================
+  -- Member comparator. Kind order: Defn(+Thm/Opaque)=0, Indc=1, Recr=2,
+  -- Ctor=3, Axiom=4, Quot=5 (mirror kconst_kind_ord).
+  -- ==========================================================================
+  fn canon_kind_ord(c: KConstantInfo) -> G {
     match c {
       KConstantInfo.Defn(_, _, _, _, _) => 0,
       KConstantInfo.Thm(_, _, _) => 0,
       KConstantInfo.Opaque(_, _, _, _) => 0,
-      KConstantInfo.Induct(_, _, _, _, _, _, _) => 1,
-      KConstantInfo.Rec(_, _, _, _, _, _, _, _, _, _) => 2,
-      KConstantInfo.Ctor(_, _, _, _, _, _, _) => 3,
+      KConstantInfo.Induct(_, _, _, _, _, _, _, _) => 1,
+      KConstantInfo.Rec(_, _, _, _, _, _, _, _, _, _, _) => 2,
+      KConstantInfo.Ctor(_, _, _, _, _, _, _, _) => 3,
       KConstantInfo.Axiom(_, _, _) => 4,
       KConstantInfo.Quot(_, _, _) => 5,
     }
   }
 
-  fn compare_kconst(x: KConstantInfo, y: KConstantInfo) -> G {
-    let kx = kconst_kind_ord(x);
-    let ky = kconst_kind_ord(y);
-    let kord = ord_cmp_g(kx, ky);
-    match kord {
-      1 => compare_kconst_same_kind(x, y),
-      _ => kord,
-    }
-  }
-
-  fn compare_kconst_same_kind(x: KConstantInfo, y: KConstantInfo) -> G {
-    match x {
-      KConstantInfo.Defn(xn, xt, xv, _xs, _xh) =>
-        match y {
-          KConstantInfo.Defn(yn, yt, yv, _ys, _yh) =>
-            ord_then(ord_cmp_g(xn, yn),
-              ord_then(compare_kexpr(xt, yt), compare_kexpr(xv, yv))),
-        },
-      KConstantInfo.Thm(xn, xt, xv) =>
-        match y {
-          KConstantInfo.Thm(yn, yt, yv) =>
-            ord_then(ord_cmp_g(xn, yn),
-              ord_then(compare_kexpr(xt, yt), compare_kexpr(xv, yv))),
-        },
-      KConstantInfo.Opaque(xn, xt, xv, xu) =>
-        match y {
-          KConstantInfo.Opaque(yn, yt, yv, yu) =>
-            ord_then(ord_cmp_g(xn, yn),
-              ord_then(compare_kexpr(xt, yt),
-                ord_then(compare_kexpr(xv, yv), ord_cmp_g(xu, yu)))),
-        },
-      KConstantInfo.Quot(xn, xt, _xk) =>
-        match y {
-          KConstantInfo.Quot(yn, yt, _yk) =>
-            ord_then(ord_cmp_g(xn, yn), compare_kexpr(xt, yt)),
-        },
-      KConstantInfo.Axiom(xn, xt, xu) =>
-        match y {
-          KConstantInfo.Axiom(yn, yt, yu) =>
-            ord_then(ord_cmp_g(xn, yn),
-              ord_then(compare_kexpr(xt, yt), ord_cmp_g(xu, yu))),
-        },
-      -- PARTIAL mirror of src/ix/kernel/canonical_check.rs compare_kindc:
-      -- (is_unsafe, lvls, params, indices, ctors_len, ty) — the ctors[*]
-      -- tail is MISSING (needs `top` to resolve ctor positions), so
-      -- same-shape mutual inductives compare equal here. This ctx-less
-      -- comparator is currently unreachable; the live path is
-      -- compare_kconst_ctx, which does compare ctors.
-      KConstantInfo.Induct(xn, xt, xp, xi, xc, xu, _xa) =>
-        match y {
-          KConstantInfo.Induct(yn, yt, yp, yi, yc, yu, _ya) =>
-            ord_then(ord_cmp_g(xu, yu),
-              ord_then(ord_cmp_g(xn, yn),
-                ord_then(ord_cmp_g(xp, yp),
-                  ord_then(ord_cmp_g(xi, yi),
-                    ord_then(ord_cmp_g(list_length(xc), list_length(yc)),
-                      compare_kexpr(xt, yt)))))),
-        },
-      -- Mirror: src/ix/kernel/canonical_check.rs:346-368 compare_kctor
-      -- order: (lvls, cidx, params, fields, ty). induct_idx + unsafe excluded
-      -- from comparator key (see Rust source).
-      KConstantInfo.Ctor(xn, xt, _xi, xc, xp, xf, _xu) =>
-        match y {
-          KConstantInfo.Ctor(yn, yt, _yi, yc, yp, yf, _yu) =>
-            ord_then(ord_cmp_g(xn, yn),
-              ord_then(ord_cmp_g(xc, yc),
-                ord_then(ord_cmp_g(xp, yp),
-                  ord_then(ord_cmp_g(xf, yf), compare_kexpr(xt, yt))))),
-        },
-      -- Mirror: src/ix/kernel/canonical_check.rs:374-407 compare_krecr
-      -- order: (lvls, params, indices, motives, minors, k, ty, rules).
-      KConstantInfo.Rec(xn, xt, xp, xi, xm, xmi, xrules, xk, _xu, _xba) =>
-        match y {
-          KConstantInfo.Rec(yn, yt, yp, yi, ym, ymi, yrules, yk, _yu, _yba) =>
-            ord_then(ord_cmp_g(xn, yn),
-              ord_then(ord_cmp_g(xp, yp),
-                ord_then(ord_cmp_g(xi, yi),
-                  ord_then(ord_cmp_g(xm, ym),
-                    ord_then(ord_cmp_g(xmi, ymi),
-                      ord_then(ord_cmp_g(xk, yk),
-                        ord_then(compare_kexpr(xt, yt),
-                          compare_krec_rule_list(xrules, yrules)))))))),
-        },
-    }
-  }
-
-
-  -- ctx-aware variant: SOrd-returning, threads ctx into compare_kexpr_ctx.
-  -- `top` is the resolve_ctor analogue: Indc comparison resolves each
-  -- ctor position through it (mirror: canonical_check.rs compare_kconst's
-  -- `resolve_ctor` parameter). `addrs` backs the external-ref address
-  -- compare in ctx_cmp_idx.
-  fn compare_kconst_ctx(x: KConstantInfo, y: KConstantInfo,
-                        ctx: List‹(G, G)›, top: List‹&KConstantInfo›,
-                        addrs: List‹Addr›) -> (G, G) {
-    let kx = kconst_kind_ord(x);
-    let ky = kconst_kind_ord(y);
-    let kord = ord_cmp_g(kx, ky);
+  fn canon_cmp_member_ctx(x: KConstantInfo, y: KConstantInfo,
+                        ctx: List‹(Addr, G)›) -> (G, G) {
+    let kord = canon_ord_cmp_g(canon_kind_ord(x), canon_kind_ord(y));
     match kord {
-      1 => compare_kconst_same_kind_ctx(x, y, ctx, top, addrs),
-      _ => sord_of_g(kord),
+      1 => canon_cmp_member_same_kind_ctx(x, y, ctx),
+      _ => canon_sord_of_g(kord),
     }
   }
 
-  fn compare_kconst_same_kind_ctx(x: KConstantInfo, y: KConstantInfo,
-                                   ctx: List‹(G, G)›, top: List‹&KConstantInfo›,
-                                   addrs: List‹Addr›) -> (G, G) {
+  fn canon_cmp_member_same_kind_ctx(x: KConstantInfo, y: KConstantInfo,
+                                  ctx: List‹(Addr, G)›) -> (G, G) {
     match x {
       KConstantInfo.Defn(xn, xt, xv, _xs, _xh) =>
         match y {
           KConstantInfo.Defn(yn, yt, yv, _ys, _yh) =>
-            sord_then(sord_of_g(ord_cmp_g(xn, yn)),
-              sord_then(compare_kexpr_ctx(xt, yt, ctx, addrs),
-                         compare_kexpr_ctx(xv, yv, ctx, addrs))),
-        },
-      KConstantInfo.Thm(xn, xt, xv) =>
-        match y {
-          KConstantInfo.Thm(yn, yt, yv) =>
-            sord_then(sord_of_g(ord_cmp_g(xn, yn)),
-              sord_then(compare_kexpr_ctx(xt, yt, ctx, addrs),
-                         compare_kexpr_ctx(xv, yv, ctx, addrs))),
-        },
-      KConstantInfo.Opaque(xn, xt, xv, xu) =>
-        match y {
-          KConstantInfo.Opaque(yn, yt, yv, yu) =>
-            sord_then(sord_of_g(ord_cmp_g(xn, yn)),
-              sord_then(compare_kexpr_ctx(xt, yt, ctx, addrs),
-                sord_then(compare_kexpr_ctx(xv, yv, ctx, addrs),
-                           sord_of_g(ord_cmp_g(xu, yu))))),
-        },
-      KConstantInfo.Quot(xn, xt, _xk) =>
-        match y {
-          KConstantInfo.Quot(yn, yt, _yk) =>
-            sord_then(sord_of_g(ord_cmp_g(xn, yn)),
-                       compare_kexpr_ctx(xt, yt, ctx, addrs)),
-        },
-      KConstantInfo.Axiom(xn, xt, xu) =>
-        match y {
-          KConstantInfo.Axiom(yn, yt, yu) =>
-            sord_then(sord_of_g(ord_cmp_g(xn, yn)),
-              sord_then(compare_kexpr_ctx(xt, yt, ctx, addrs),
-                         sord_of_g(ord_cmp_g(xu, yu)))),
-        },
-      -- Mirror: canonical_check.rs:299-338 compare_kindc —
-      -- (is_unsafe, lvls, params, indices, |ctors|, ty, ctors[*]).
-      -- The ctors tail is what separates same-shape mutual inductives
-      -- (e.g. Mathlib's ExBase/ExProd/ExSum: identical flags, arities
-      -- and types, differing only in ctor types).
-      KConstantInfo.Induct(xn, xt, xp, xi, xc, xu, _xa) =>
-        match y {
-          KConstantInfo.Induct(yn, yt, yp, yi, yc, yu, _ya) =>
-            sord_then(sord_of_g(ord_cmp_g(xu, yu)),
-              sord_then(sord_of_g(ord_cmp_g(xn, yn)),
-                sord_then(sord_of_g(ord_cmp_g(xp, yp)),
-                  sord_then(sord_of_g(ord_cmp_g(xi, yi)),
-                    sord_then(sord_of_g(ord_cmp_g(list_length(xc), list_length(yc))),
-                      sord_then(compare_kexpr_ctx(xt, yt, ctx, addrs),
-                                 compare_kctor_idxs_ctx(xc, yc, ctx, top, addrs))))))),
-        },
-      KConstantInfo.Ctor(xn, xt, _xi, xc, xp, xf, _xu) =>
-        match y {
-          KConstantInfo.Ctor(yn, yt, _yi, yc, yp, yf, _yu) =>
-            sord_then(sord_of_g(ord_cmp_g(xn, yn)),
-              sord_then(sord_of_g(ord_cmp_g(xc, yc)),
-                sord_then(sord_of_g(ord_cmp_g(xp, yp)),
-                  sord_then(sord_of_g(ord_cmp_g(xf, yf)),
-                             compare_kexpr_ctx(xt, yt, ctx, addrs))))),
-        },
-      KConstantInfo.Rec(xn, xt, xp, xi, xm, xmi, xrules, xk, _xu, _xba) =>
-        match y {
-          KConstantInfo.Rec(yn, yt, yp, yi, ym, ymi, yrules, yk, _yu, _yba) =>
-            sord_then(sord_of_g(ord_cmp_g(xn, yn)),
-              sord_then(sord_of_g(ord_cmp_g(xp, yp)),
-                sord_then(sord_of_g(ord_cmp_g(xi, yi)),
-                  sord_then(sord_of_g(ord_cmp_g(xm, ym)),
-                    sord_then(sord_of_g(ord_cmp_g(xmi, ymi)),
-                      sord_then(sord_of_g(ord_cmp_g(xk, yk)),
-                        sord_then(compare_kexpr_ctx(xt, yt, ctx, addrs),
-                                   compare_krec_rule_list_ctx(xrules, yrules, ctx, addrs)))))))),
-        },
-    }
-  }
-
-  -- Mirror: canonical_check.rs:322-336 (compare_kindc's ctors tail via
-  -- SOrd::try_zip). Walks both ctor-position lists in lockstep, resolving
-  -- each position through `top` and comparing the Ctor payloads. List
-  -- lengths are compared upstream (|ctors| field), so both lists exhaust
-  -- together; the fold mirrors try_zip's lex/weak-propagation semantics.
-  fn compare_kctor_idxs_ctx(xs: List‹G›, ys: List‹G›, ctx: List‹(G, G)›,
-                             top: List‹&KConstantInfo›, addrs: List‹Addr›) -> (G, G) {
-    match load(xs) {
-      ListNode.Nil => sord_eq_strong(),
-      ListNode.Cons(xpos, xrest) =>
-        match load(ys) {
-          ListNode.Nil => sord_eq_strong(),
-          ListNode.Cons(ypos, yrest) =>
-            sord_then(
-              compare_kctor_pair_ctx(load(list_lookup(top, xpos)),
-                                     load(list_lookup(top, ypos)), ctx, addrs),
-              compare_kctor_idxs_ctx(xrest, yrest, ctx, top, addrs)),
-        },
+            canon_sord_then(canon_sord_of_g(canon_ord_cmp_g(xn, yn)),
+              canon_sord_then(canon_cmp_kexpr_ctx(xt, yt, ctx),
+                            canon_cmp_kexpr_ctx(xv, yv, ctx))),
+          _ => canon_sord_eq_strong(),
+        },
+      -- (is_unsafe, lvls, params, indices, |ctors|, ty, ctors[*]) —
+      -- mirror canonical_check.rs compare_kindc. The ctors tail is what
+      -- separates same-shape mutual inductives.
+      KConstantInfo.Induct(xn, xt, xp, xi, xc, xu, xba, xidx) =>
+        match y {
+          KConstantInfo.Induct(yn, yt, yp, yi, yc, yu, yba, yidx) =>
+            canon_sord_then(canon_sord_of_g(canon_ord_cmp_g(xu, yu)),
+              canon_sord_then(canon_sord_of_g(canon_ord_cmp_g(xn, yn)),
+                canon_sord_then(canon_sord_of_g(canon_ord_cmp_g(xp, yp)),
+                  canon_sord_then(canon_sord_of_g(canon_ord_cmp_g(xi, yi)),
+                    canon_sord_then(canon_sord_of_g(canon_ord_cmp_g(xc, yc)),
+                      canon_sord_then(canon_cmp_kexpr_ctx(xt, yt, ctx),
+                        canon_cmp_ctor_range_ctx(xba, xidx, yba, yidx,
+                                               xc, ctx, 0))))))),
+          _ => canon_sord_eq_strong(),
+        },
+      KConstantInfo.Rec(xn, xt, xp, xi, xm, xmi, xrules, xk, _xu, _xba, _xr) =>
+        match y {
+          KConstantInfo.Rec(yn, yt, yp, yi, ym, ymi, yrules, yk, _yu, _yba, _yr) =>
+            canon_sord_then(canon_sord_of_g(canon_ord_cmp_g(xn, yn)),
+              canon_sord_then(canon_sord_of_g(canon_ord_cmp_g(xp, yp)),
+                canon_sord_then(canon_sord_of_g(canon_ord_cmp_g(xi, yi)),
+                  canon_sord_then(canon_sord_of_g(canon_ord_cmp_g(xm, ym)),
+                    canon_sord_then(canon_sord_of_g(canon_ord_cmp_g(xmi, ymi)),
+                      canon_sord_then(canon_sord_of_g(canon_ord_cmp_g(xk, yk)),
+                        canon_sord_then(canon_cmp_kexpr_ctx(xt, yt, ctx),
+                          canon_cmp_krec_rule_list_ctx(xrules, yrules, ctx)))))))),
+          _ => canon_sord_eq_strong(),
+        },
+      _ => canon_sord_eq_strong(),
+    }
+  }
+
+  -- Walk cidx 0..nc, resolving each ctor from both inductives via
+  -- get_ci_cprj (mirror compare_kctor_idxs_ctx; |ctors| compared
+  -- upstream so both ranges exhaust together).
+  fn canon_cmp_ctor_range_ctx(xba: Addr, xidx: G, yba: Addr, yidx: G,
+                            nc: G, ctx: List‹(Addr, G)›, c: G) -> (G, G) {
+    match nc - c {
+      0 => canon_sord_eq_strong(),
+      _ =>
+        let xc = load(get_ci_cprj(xba, xidx, c));
+        let yc = load(get_ci_cprj(yba, yidx, c));
+        canon_sord_then(canon_cmp_ctor_pair_ctx(xc, yc, ctx),
+                      canon_cmp_ctor_range_ctx(xba, xidx, yba, yidx,
+                                             nc, ctx, c + 1)),
     }
   }
 
-  -- Mirror: canonical_check.rs:343-365 compare_kctor —
-  -- (lvls, cidx, params, fields, ty); induct_idx + unsafe excluded from
-  -- the comparator key. Non-Ctor operands fall back to kind ordering
-  -- (comparator stays total on malformed blocks, same as Rust).
-  fn compare_kctor_pair_ctx(x: KConstantInfo, y: KConstantInfo,
-                             ctx: List‹(G, G)›, addrs: List‹Addr›) -> (G, G) {
+  -- (lvls, cidx, params, fields, ty) — block/ind_idx/unsafe excluded
+  -- (mirror compare_kctor).
+  fn canon_cmp_ctor_pair_ctx(x: KConstantInfo, y: KConstantInfo,
+                           ctx: List‹(Addr, G)›) -> (G, G) {
     match x {
-      KConstantInfo.Ctor(xn, xt, _xi, xc, xp, xf, _xu) =>
+      KConstantInfo.Ctor(xn, xt, _xb, _xi, xc, xp, xf, _xu) =>
         match y {
-          KConstantInfo.Ctor(yn, yt, _yi, yc, yp, yf, _yu) =>
-            sord_then(sord_of_g(ord_cmp_g(xn, yn)),
-              sord_then(sord_of_g(ord_cmp_g(xc, yc)),
-                sord_then(sord_of_g(ord_cmp_g(xp, yp)),
-                  sord_then(sord_of_g(ord_cmp_g(xf, yf)),
-                             compare_kexpr_ctx(xt, yt, ctx, addrs))))),
-          _ => sord_of_g(ord_cmp_g(kconst_kind_ord(x), kconst_kind_ord(y))),
-        },
-      _ => sord_of_g(ord_cmp_g(kconst_kind_ord(x), kconst_kind_ord(y))),
-    }
-  }
-
-  -- Build ctx (list of kernel positions) for all consts in `top` whose
-  -- block_addr equals `target`. Walks `top` once with a position counter.
-  fn block_members_of(target: Addr, top: List‹&KConstantInfo›,
-                       all_top: List‹&KConstantInfo›, pos: G) -> List‹G› {
-    match load(top) {
-      ListNode.Nil => store(ListNode.Nil),
-      ListNode.Cons(&ci, rest) =>
-        let ba = kconst_block_addr(ci, all_top);
-        let rest_members = block_members_of(target, rest, all_top, pos + 1);
-        match address_eq(ba, target) {
-          1 => store(ListNode.Cons(pos, rest_members)),
-          0 => rest_members,
-        },
-    }
-  }
-
-  -- Walks `top` finding adjacent KConstantInfo pairs that share a derived
-  -- block_addr. Asserts strict-lt for each such pair. Block_addr derivation:
-  --   Induct → its own 10th-field block_addr.
-  --   Ctor   → parent Induct's block_addr (via induct_idx lookup).
-  --   Rec    → block_addr of the parent of its first rule's ctor.
-  --   Other  → [0;32] (not part of a Muts block).
-  fn check_canonical_block_sort(top: List‹&KConstantInfo›, addrs: List‹Addr›) {
-    check_canonical_block_sort_walk(top, store([0u8; 32]), store(ListNode.Nil), 0, top, addrs)
-  }
-
-  fn kconst_block_addr(ci: KConstantInfo, top: List‹&KConstantInfo›) -> Addr {
-    match ci {
-      KConstantInfo.Induct(_, _, _, _, _, _, ba) => ba,
-      KConstantInfo.Ctor(_, _, induct_idx, _, _, _, _) =>
-        let ind_ci = load(list_lookup(top, induct_idx));
-        match ind_ci {
-          KConstantInfo.Induct(_, _, _, _, _, _, ba) => ba,
-          _ => store([0u8; 32]),
-        },
-      KConstantInfo.Rec(_, _, _, _, _, _, _, _, _, ba) => ba,
-      _ => store([0u8; 32]),
-    }
-  }
-
-  -- Walk top, group consecutive consts sharing a non-zero block_addr,
-  -- and validate each block via iterative refinement.
-  fn check_canonical_block_sort_walk(consts: List‹&KConstantInfo›,
-                                     cur_ba: Addr,
-                                     cur_members: List‹G›,
-                                     pos: G,
-                                     top: List‹&KConstantInfo›,
-                                     addrs: List‹Addr›) {
-    match load(consts) {
-      ListNode.Nil => validate_block_if_nonzero(cur_ba, cur_members, top, addrs),
-      ListNode.Cons(&ci, rest) =>
-        let ba = kconst_block_addr(ci, top);
-        match address_eq(ba, cur_ba) {
-          1 =>
-            check_canonical_block_sort_walk(rest, ba, list_snoc(cur_members, pos),
-                                             pos + 1, top, addrs),
-          0 =>
-            validate_block_if_nonzero(cur_ba, cur_members, top, addrs);
-            let new_members = init_block_members(ba, pos);
-            check_canonical_block_sort_walk(rest, ba, new_members, pos + 1, top, addrs),
-        },
-    }
-  }
-
-  fn init_block_members(ba: Addr, pos: G) -> List‹G› {
-    match address_eq(ba, store([0u8; 32])) {
-      1 => store(ListNode.Nil),
-      0 => store(ListNode.Cons(pos, store(ListNode.Nil))),
-    }
-  }
-
-  fn validate_block_if_nonzero(ba: Addr, members: List‹G›,
-                                top: List‹&KConstantInfo›,
-                                addrs: List‹Addr›) {
-    match address_eq(ba, store([0u8; 32])) {
-      1 => (),
-      0 =>
-        match list_length(members) {
-          0 => (),
-          1 => (),
-          _ => validate_block_canonical(members, top, addrs),
+          KConstantInfo.Ctor(yn, yt, _yb, _yi, yc, yp, yf, _yu) =>
+            canon_sord_then(canon_sord_of_g(canon_ord_cmp_g(xn, yn)),
+              canon_sord_then(canon_sord_of_g(canon_ord_cmp_g(xc, yc)),
+                canon_sord_then(canon_sord_of_g(canon_ord_cmp_g(xp, yp)),
+                  canon_sord_then(canon_sord_of_g(canon_ord_cmp_g(xf, yf)),
+                                canon_cmp_kexpr_ctx(xt, yt, ctx))))),
+          _ => canon_sord_of_g(canon_ord_cmp_g(canon_kind_ord(x), canon_kind_ord(y))),
         },
+      _ => canon_sord_of_g(canon_ord_cmp_g(canon_kind_ord(x), canon_kind_ord(y))),
     }
   }
 
-  -- Mirror: src/ix/kernel/canonical_check.rs:732-762 validate_by_full_refinement.
-  -- Run sort_kconsts, assert all classes are singletons, and stored order
-  -- matches the canonical sort. Equal classes (size > 1) signal an alpha-
-  -- collision in the block — Lean's compiler should have collapsed those.
-  -- Mirror Rust ingress.rs:2025-2048: validate canonical order for
-  -- Indc subset only. Ctors share parent's block_addr in our walk but
-  -- aren't actual block members per Rust's KConst::Indc.block field.
-  fn validate_block_canonical(stored: List‹G›, top: List‹&KConstantInfo›,
-                              addrs: List‹Addr›) {
-    let stored_indcs = filter_indc_positions(stored, top);
-    match list_length(stored_indcs) {
-      0 => (),
-      1 => (),
-      _ =>
-        let classes = sort_kconsts(stored_indcs, top, addrs);
-        let sing = all_singleton_classes(classes);
-        let sorted = flatten_classes(classes);
-        let eq = g_list_eq(sorted, stored_indcs);
-        assert_eq!(sing, 1);
-        assert_eq!(eq, 1);
-        (),
-    }
+  -- ==========================================================================
+  -- Block-local addr synthesis. Member proj addrs come from
+  -- build_recur_addrs; ctor CPrj addrs mirror the compile-emitted
+  -- wrapper serialization (same scheme as projection_addr).
+  -- ==========================================================================
+  fn canon_cprj_addr(block: Addr, ind_idx: G, cidx: G) -> Addr {
+    let info = ConstantInfo.CPrj(ConstructorProj.Mk(
+      idx_to_u64(ind_idx), idx_to_u64(cidx), block));
+    let proj_c = Constant.Mk(info,
+                             store(ListNode.Nil),
+                             store(ListNode.Nil),
+                             store(ListNode.Nil));
+    let bytes = put_constant(proj_c, store(ListNode.Nil));
+    bytes_to_addr(bytes)
   }
 
-  fn filter_indc_positions(positions: List‹G›,
-                           top: List‹&KConstantInfo›) -> List‹G› {
-    match load(positions) {
-      ListNode.Nil => store(ListNode.Nil),
-      ListNode.Cons(p, rest) =>
-        let ci = load(list_lookup(top, p));
-        let rest_filtered = filter_indc_positions(rest, top);
-        match kconst_kind_ord(ci) {
-          1 => store(ListNode.Cons(p, rest_filtered)),
-          _ => rest_filtered,
-        },
-    }
+  -- Member KCI at position, via its projection wrapper addr (memoized
+  -- by get_ci).
+  fn canon_member_ci(proj_addrs: List‹Addr›, pos: G) -> KConstantInfo {
+    load(get_ci(list_lookup(proj_addrs, pos)))
   }
 
-  fn all_singleton_classes(classes: List‹List‹G››) -> G {
-    match load(classes) {
-      ListNode.Nil => 1,
-      ListNode.Cons(c, rest) =>
-        match list_length(c) {
-          1 => all_singleton_classes(rest),
-          _ => 0,
-        },
-    }
-  }
-
-  fn flatten_classes(classes: List‹List‹G››) -> List‹G› {
-    match load(classes) {
-      ListNode.Nil => store(ListNode.Nil),
-      ListNode.Cons(c, rest) =>
-        list_concat(c, flatten_classes(rest)),
+  fn canon_member_num_ctors(proj_addrs: List‹Addr›, pos: G) -> G {
+    match canon_member_ci(proj_addrs, pos) {
+      KConstantInfo.Induct(_, _, _, _, nc, _, _, _) => nc,
+      _ => 0,
     }
   }
 
-  fn g_list_eq(xs: List‹G›, ys: List‹G›) -> G {
-    match load(xs) {
-      ListNode.Nil =>
-        match load(ys) {
-          ListNode.Nil => 1,
-          _ => 0,
-        },
-      ListNode.Cons(x, xt) =>
-        match load(ys) {
-          ListNode.Nil => 0,
-          ListNode.Cons(y, yt) =>
-            match x - y {
-              0 => g_list_eq(xt, yt),
-              _ => 0,
-            },
-        },
-    }
-  }
-
-  -- ============================================================================
-  -- Iterative refinement: sort_kconsts (mirror canonical_check.rs:650-696).
-  --
-  -- Seed: members in stored order (single class).
-  -- Loop:
-  --   1. ctx = KMutCtx over current classes (build_mut_ctx).
-  --   2. For each multi-element class: sort by compare_kconst_ctx, then
-  --      group consecutive equals.
-  --   3. If new partition equals previous: done.
-  -- Fuel: each non-fixpoint iteration splits ≥1 class and class count is
-  -- bounded by |members|, so 1 + |members| iterations always reach the
-  -- fixpoint (Rust loops unboundedly; a fixed constant would silently
-  -- truncate refinement on very wide blocks).
-  -- ============================================================================
-  fn sort_kconsts(members: List‹G›, top: List‹&KConstantInfo›,
-                  addrs: List‹Addr›) -> List‹List‹G›› {
-    let seed = store(ListNode.Cons(members, store(ListNode.Nil)));
-    sort_kconsts_loop(seed, top, addrs, 1 + list_length(members))
-  }
-
-  fn sort_kconsts_loop(classes: List‹List‹G››, top: List‹&KConstantInfo›,
-                        addrs: List‹Addr›, fuel: G) -> List‹List‹G›› {
-    match fuel {
-      0 => classes,
-      _ =>
-        let ctx = build_mut_ctx(classes, top);
-        let new_classes = refine_classes(classes, ctx, top, addrs);
-        match classes_eq(classes, new_classes) {
-          1 => classes,
-          _ => sort_kconsts_loop(new_classes, top, addrs, fuel - 1),
-        },
-    }
-  }
-
-  -- ============================================================================
-  -- KMutCtx builder. Mirror: canonical_check.rs:100-118
-  -- KMutCtx::from_id_classes — class members map to their class index j
-  -- (ALL members of a class share j, so refs to tied members compare
-  -- weak-Equal instead of taking a position-derived tiebreak), and each
-  -- Indc member's ctors map to i + cidx, where i starts at |classes| and
-  -- advances by each class's max ctor count.
-  -- ============================================================================
-  fn build_mut_ctx(classes: List‹List‹G››,
-                   top: List‹&KConstantInfo›) -> List‹(G, G)› {
-    build_mut_ctx_classes(classes, top, 0, list_length(classes))
+  -- ==========================================================================
+  -- KMutCtx builder (mirror build_mut_ctx / KMutCtx::from_id_classes):
+  -- class members map to class index j (all tied members share j → weak
+  -- Equal), each Indc member's ctors map to i + cidx where i starts at
+  -- |classes| and advances by each class's max ctor count.
+  -- ==========================================================================
+  fn canon_build_ctx(classes: List‹List‹G››, proj_addrs: List‹Addr›,
+                   block: Addr) -> List‹(Addr, G)› {
+    canon_build_ctx_classes(classes, proj_addrs, block, 0, list_length(classes))
   }
 
-  fn build_mut_ctx_classes(classes: List‹List‹G››, top: List‹&KConstantInfo›,
-                           j: G, i: G) -> List‹(G, G)› {
+  fn canon_build_ctx_classes(classes: List‹List‹G››, proj_addrs: List‹Addr›,
+                           block: Addr, j: G, i: G) -> List‹(Addr, G)› {
     match load(classes) {
       ListNode.Nil => store(ListNode.Nil),
       ListNode.Cons(cls, rest) =>
-        let (entries, max_ctors) = build_mut_ctx_members(cls, top, j, i);
+        let (entries, max_ctors) =
+          canon_build_ctx_members(cls, proj_addrs, block, j, i);
         list_concat(entries,
-                    build_mut_ctx_classes(rest, top, j + 1, i + max_ctors)),
+          canon_build_ctx_classes(rest, proj_addrs, block, j + 1, i + max_ctors)),
     }
   }
 
-  -- Entries for one class's members (+ their ctors); also returns the
-  -- class's max ctor count for the caller's `i` advance.
-  fn build_mut_ctx_members(members: List‹G›, top: List‹&KConstantInfo›,
-                           j: G, i: G) -> (List‹(G, G)›, G) {
+  fn canon_build_ctx_members(members: List‹G›, proj_addrs: List‹Addr›,
+                           block: Addr, j: G, i: G)
+                           -> (List‹(Addr, G)›, G) {
     match load(members) {
       ListNode.Nil => (store(ListNode.Nil), 0),
       ListNode.Cons(pos, rest) =>
-        let (rest_entries, rest_max) = build_mut_ctx_members(rest, top, j, i);
-        let ctors = kconst_ctor_idxs(load(list_lookup(top, pos)));
-        let n = list_length(ctors);
-        let ctor_entries = ctor_ctx_entries(ctors, i, 0);
-        let entries = store(ListNode.Cons((pos, j),
-                            list_concat(ctor_entries, rest_entries)));
+        let (rest_entries, rest_max) =
+          canon_build_ctx_members(rest, proj_addrs, block, j, i);
+        let n = canon_member_num_ctors(proj_addrs, pos);
+        let ctor_entries = canon_ctor_ctx_entries(block, pos, n, i, 0);
+        let entries = store(ListNode.Cons(
+          (list_lookup(proj_addrs, pos), j),
+          list_concat(ctor_entries, rest_entries)));
         match u32_less_than(rest_max, n) {
           1 => (entries, n),
           _ => (entries, rest_max),
@@ -1062,100 +580,115 @@ def canonicalCheck := ⟦
     }
   }
 
-  fn ctor_ctx_entries(ctors: List‹G›, i: G, cidx: G) -> List‹(G, G)› {
-    match load(ctors) {
-      ListNode.Nil => store(ListNode.Nil),
-      ListNode.Cons(cpos, rest) =>
-        store(ListNode.Cons((cpos, i + cidx),
-                            ctor_ctx_entries(rest, i, cidx + 1))),
+  fn canon_ctor_ctx_entries(block: Addr, ind_idx: G, n: G, i: G,
+                          cidx: G) -> List‹(Addr, G)› {
+    match n - cidx {
+      0 => store(ListNode.Nil),
+      _ =>
+        store(ListNode.Cons((canon_cprj_addr(block, ind_idx, cidx), i + cidx),
+          canon_ctor_ctx_entries(block, ind_idx, n, i, cidx + 1))),
     }
   }
 
-  -- Mirror: canonical_check.rs:73-77 cnst_ctors — Indc's ctor positions,
-  -- empty for every other kind.
-  fn kconst_ctor_idxs(ci: KConstantInfo) -> List‹G› {
-    match ci {
-      KConstantInfo.Induct(_, _, _, _, ctor_indices, _, _) => ctor_indices,
-      _ => store(ListNode.Nil),
+  -- ==========================================================================
+  -- Iterative partition refinement (mirror sort_kconsts,
+  -- canonical_check.rs:650-696). Fuel = 1 + |members| always reaches
+  -- the fixpoint (each non-fixpoint round splits ≥1 class).
+  -- ==========================================================================
+  fn canon_sort_members(members: List‹G›, proj_addrs: List‹Addr›,
+                      block: Addr) -> List‹List‹G›› {
+    let seed = store(ListNode.Cons(members, store(ListNode.Nil)));
+    canon_sort_loop(seed, proj_addrs, block, 1 + list_length(members))
+  }
+
+  fn canon_sort_loop(classes: List‹List‹G››, proj_addrs: List‹Addr›,
+                   block: Addr, fuel: G) -> List‹List‹G›› {
+    match fuel {
+      0 => classes,
+      _ =>
+        let ctx = canon_build_ctx(classes, proj_addrs, block);
+        let new_classes = canon_refine_classes(classes, ctx, proj_addrs);
+        match canon_classes_eq(classes, new_classes) {
+          1 => classes,
+          _ => canon_sort_loop(new_classes, proj_addrs, block, fuel - 1),
+        },
     }
   }
 
-  fn refine_classes(classes: List‹List‹G››, ctx: List‹(G, G)›,
-                     top: List‹&KConstantInfo›,
-                     addrs: List‹Addr›) -> List‹List‹G›› {
+  fn canon_refine_classes(classes: List‹List‹G››, ctx: List‹(Addr, G)›,
+                        proj_addrs: List‹Addr›) -> List‹List‹G›› {
     match load(classes) {
       ListNode.Nil => store(ListNode.Nil),
       ListNode.Cons(c, rest) =>
-        let refined = refine_one_class(c, ctx, top, addrs);
-        list_concat(refined, refine_classes(rest, ctx, top, addrs)),
+        let refined = canon_refine_one(c, ctx, proj_addrs);
+        list_concat(refined, canon_refine_classes(rest, ctx, proj_addrs)),
     }
   }
 
-  fn refine_one_class(c: List‹G›, ctx: List‹(G, G)›,
-                       top: List‹&KConstantInfo›,
-                       addrs: List‹Addr›) -> List‹List‹G›› {
+  fn canon_refine_one(c: List‹G›, ctx: List‹(Addr, G)›,
+                    proj_addrs: List‹Addr›) -> List‹List‹G›› {
     match list_length(c) {
       0 => store(ListNode.Nil),
       1 => store(ListNode.Cons(c, store(ListNode.Nil))),
       _ =>
-        let sorted = insertion_sort_class(c, ctx, top, addrs);
-        group_consecutive_class(sorted, ctx, top, addrs),
+        let sorted = canon_ins_sort(c, ctx, proj_addrs);
+        canon_group_consec(sorted, ctx, proj_addrs),
     }
   }
 
-  fn insertion_sort_class(xs: List‹G›, ctx: List‹(G, G)›,
-                           top: List‹&KConstantInfo›,
-                           addrs: List‹Addr›) -> List‹G› {
+  fn canon_ins_sort(xs: List‹G›, ctx: List‹(Addr, G)›,
+                  proj_addrs: List‹Addr›) -> List‹G› {
     match load(xs) {
       ListNode.Nil => store(ListNode.Nil),
       ListNode.Cons(x, rest) =>
-        insert_sorted(x, insertion_sort_class(rest, ctx, top, addrs), ctx, top, addrs),
+        canon_insert_sorted(x, canon_ins_sort(rest, ctx, proj_addrs),
+                          ctx, proj_addrs),
     }
   }
 
-  fn insert_sorted(x: G, sorted: List‹G›, ctx: List‹(G, G)›,
-                    top: List‹&KConstantInfo›, addrs: List‹Addr›) -> List‹G› {
+  fn canon_insert_sorted(x: G, sorted: List‹G›, ctx: List‹(Addr, G)›,
+                       proj_addrs: List‹Addr›) -> List‹G› {
     match load(sorted) {
       ListNode.Nil => store(ListNode.Cons(x, store(ListNode.Nil))),
       ListNode.Cons(h, rest) =>
-        match compare_kconst_ctx(load(list_lookup(top, x)),
-                                  load(list_lookup(top, h)), ctx, top, addrs) {
+        match canon_cmp_member_ctx(canon_member_ci(proj_addrs, x),
+                                 canon_member_ci(proj_addrs, h), ctx) {
           (0, _) => store(ListNode.Cons(x, sorted)),
-          _ => store(ListNode.Cons(h, insert_sorted(x, rest, ctx, top, addrs))),
+          _ => store(ListNode.Cons(h,
+                 canon_insert_sorted(x, rest, ctx, proj_addrs))),
         },
     }
   }
 
-  fn group_consecutive_class(sorted: List‹G›, ctx: List‹(G, G)›,
-                              top: List‹&KConstantInfo›,
-                              addrs: List‹Addr›) -> List‹List‹G›› {
+  fn canon_group_consec(sorted: List‹G›, ctx: List‹(Addr, G)›,
+                      proj_addrs: List‹Addr›) -> List‹List‹G›› {
     match load(sorted) {
       ListNode.Nil => store(ListNode.Nil),
       ListNode.Cons(h, rest) =>
-        group_consecutive_walk(rest, ctx, top, addrs, h,
-                                store(ListNode.Cons(h, store(ListNode.Nil)))),
+        canon_group_walk(rest, ctx, proj_addrs, h,
+                       store(ListNode.Cons(h, store(ListNode.Nil)))),
     }
   }
 
-  fn group_consecutive_walk(remaining: List‹G›, ctx: List‹(G, G)›,
-                             top: List‹&KConstantInfo›, addrs: List‹Addr›,
-                             last: G, current_group: List‹G›) -> List‹List‹G›› {
+  fn canon_group_walk(remaining: List‹G›, ctx: List‹(Addr, G)›,
+                    proj_addrs: List‹Addr›, last: G,
+                    current: List‹G›) -> List‹List‹G›› {
     match load(remaining) {
-      ListNode.Nil => store(ListNode.Cons(current_group, store(ListNode.Nil))),
+      ListNode.Nil => store(ListNode.Cons(current, store(ListNode.Nil))),
       ListNode.Cons(h, rest) =>
-        match compare_kconst_ctx(load(list_lookup(top, last)),
-                                  load(list_lookup(top, h)), ctx, top, addrs) {
+        match canon_cmp_member_ctx(canon_member_ci(proj_addrs, last),
+                                 canon_member_ci(proj_addrs, h), ctx) {
           (1, _) =>
-            group_consecutive_walk(rest, ctx, top, addrs, h, list_snoc(current_group, h)),
+            canon_group_walk(rest, ctx, proj_addrs, h, list_snoc(current, h)),
           _ =>
-            store(ListNode.Cons(current_group,
-              group_consecutive_walk(rest, ctx, top, addrs, h,
+            store(ListNode.Cons(current,
+              canon_group_walk(rest, ctx, proj_addrs, h,
                 store(ListNode.Cons(h, store(ListNode.Nil)))))),
         },
     }
   }
 
-  fn classes_eq(a: List‹List‹G››, b: List‹List‹G››) -> G {
+  fn canon_classes_eq(a: List‹List‹G››, b: List‹List‹G››) -> G {
     match load(a) {
       ListNode.Nil =>
         match load(b) {
@@ -1166,10 +699,94 @@ def canonicalCheck := ⟦
         match load(b) {
           ListNode.Nil => 0,
           ListNode.Cons(bh, brest) =>
-            match g_list_eq(ah, bh) {
+            match canon_g_list_eq(ah, bh) {
               0 => 0,
-              _ => classes_eq(arest, brest),
+              _ => canon_classes_eq(arest, brest),
+            },
+        },
+    }
+  }
+
+  fn canon_g_list_eq(xs: List‹G›, ys: List‹G›) -> G {
+    match load(xs) {
+      ListNode.Nil =>
+        match load(ys) {
+          ListNode.Nil => 1,
+          _ => 0,
+        },
+      ListNode.Cons(x, xt) =>
+        match load(ys) {
+          ListNode.Nil => 0,
+          ListNode.Cons(y, yt) =>
+            match x - y {
+              0 => canon_g_list_eq(xt, yt),
+              _ => 0,
+            },
+        },
+    }
+  }
+
+  fn canon_flatten(classes: List‹List‹G››) -> List‹G› {
+    match load(classes) {
+      ListNode.Nil => store(ListNode.Nil),
+      ListNode.Cons(c, rest) =>
+        list_concat(c, canon_flatten(rest)),
+    }
+  }
+
+  fn canon_all_singleton(classes: List‹List‹G››) -> G {
+    match load(classes) {
+      ListNode.Nil => 1,
+      ListNode.Cons(c, rest) =>
+        match list_length(c) {
+          1 => canon_all_singleton(rest),
+          _ => 0,
+        },
+    }
+  }
+
+  -- Indc member positions in the Muts list, ascending (mirror
+  -- filter_indc_positions / Rust ingress.rs:2025-2048 — canonical
+  -- order is validated for the Indc subset only).
+  fn canon_indc_positions(members: List‹MutConst›, pos: G) -> List‹G› {
+    match load(members) {
+      ListNode.Nil => store(ListNode.Nil),
+      ListNode.Cons(m, rest) =>
+        let tail = canon_indc_positions(rest, pos + 1);
+        match m {
+          MutConst.Indc(_) => store(ListNode.Cons(pos, tail)),
+          _ => tail,
+        },
+    }
+  }
+
+  -- ==========================================================================
+  -- Entry. Validate one Muts block's canonical member order (mirror
+  -- validate_by_full_refinement): sort the Indc members by refinement,
+  -- assert all classes are singletons (no alpha-collisions — Lean's
+  -- compiler must have collapsed those) and the canonical sort equals
+  -- the stored order. Aiur-memoized per block addr; non-Muts blocks
+  -- and blocks with <2 Indc members pass trivially.
+  -- ==========================================================================
+  fn check_canonical_block(block_addr: Addr) {
+    let c = load_verified_constant(block_addr);
+    match c {
+      Constant.Mk(info, _, _, _) =>
+        match info {
+          ConstantInfo.Muts(members) =>
+            let indcs = canon_indc_positions(members, 0);
+            match u32_less_than(list_length(indcs), 2) {
+              1 => (),
+              _ =>
+                let proj_addrs = build_recur_addrs(members, block_addr);
+                let classes = canon_sort_members(indcs, proj_addrs, block_addr);
+                assert_eq!(canon_all_singleton(classes), 1,
+                  "canonical block: refinement left members tied, order ambiguous");
+                assert_eq!(canon_g_list_eq(canon_flatten(classes), indcs), 1,
+                  "canonical block: members are not in canonical order");
+                (),
             },
+          _ => (),
         },
     }
   }
diff --git a/Ix/IxVM/Kernel/Check.lean b/Ix/IxVM/Kernel/Check.lean
index 7f3e3aa01..da72e31ad 100644
--- a/Ix/IxVM/Kernel/Check.lean
+++ b/Ix/IxVM/Kernel/Check.lean
@@ -1,91 +1,99 @@
 module
 public import Ix.Aiur.Meta
 public import Ix.IxVM.KernelTypes
-public import Ix.IxVM.Kernel.Subst
-public import Ix.IxVM.Kernel.Whnf
+public import Ix.IxVM.Kernel.Levels
 public import Ix.IxVM.Kernel.Infer
-public import Ix.IxVM.Kernel.DefEq
+public import Ix.IxVM.Ingress
 
 public section
 
 namespace IxVM
 
-/-! ## Per-constant type checking
+/-! ## Check — the per-constant typechecker
 
-Mirrors `src/ix/kernel/check.rs::check_const_member` (line 95+).
+`check_const` dispatches on the constant's variant and is the single
+entry point for "is this constant well-typed": Axiom, Defn, Thm, Opaque,
+Quot, Induct, Ctor, and Rec. The declaration-kind-specific machinery —
+inductive shape, the constructor gauntlet (return type, parameter
+agreement, field universes, strict positivity), large-eliminator
+classification, and recursor canonicality — lives in this module too.
 
-Per `KConstantInfo` variant:
+`assert_safety` enforces that a Safe-classified constant references only
+Safe constants: it walks the expression and resolves each `Const(addr)`
+through `get_ci`. That resolution is what makes the check affordable
+here — `get_ci` is memoized and the check only needs each referenced
+constant's safety classification, not its body.
 
-* `Axio { ty }` → infer ty, ensure_sort.
-* `Defn { ty, val }` → infer ty (ensure_sort), infer val, is_def_eq val_ty ty.
-* `Thm { ty, val }` → as Defn, plus assert ty's level is Prop (Sort 0).
-* `Opaque { ty, val, is_unsafe }` → ensure_sort ty; if !is_unsafe, also
-  infer val and is_def_eq.
-* `Quot { ty }` → infer ty, ensure_sort.
-* `Indc { ty }` → infer ty, ensure_sort.
-* `Ctor { ty }` → infer ty, ensure_sort.
-* `Recr { ty }` → infer ty, ensure_sort.
-
-Top-level entry: `check_all` walks the kernel const list and calls
-`check_const` per element. Failures `assert_eq!(0, 1)` to fail the proof.
+Scope validation: `validate_univ_params_seen` universe-only —
+included here (no addr work).
 -/
 
+set_option maxRecDepth 32768 in
 def check := ⟦
-  -- Mirror: each KConstantInfo's unsafe flag (Defn = DefinitionSafety,
-  -- others = G). Returns 1 if unsafe, 0 if safe. Thm and Quot are always safe.
+  -- Mirror is_unsafe_ci: 1 if a SAFE constant may not reference it, 0
+  -- otherwise. Thm/Quot always safe.
+  --
+  -- `Partial` counts alongside `Unsafe`, matching the reference's
+  -- "safe definition references partial definition" rejection
+  -- (crates/kernel/src/check.rs). This is load-bearing rather than
+  -- cosmetic: a partial definition may reference ITSELF (see the recur
+  -- slot in Ingress), and `k_infer` discharges a `Const` against its
+  -- declared type without checking it, so `partial def bad : False := bad`
+  -- typechecks in isolation. Barring safe code from referencing it is what
+  -- keeps that out of the trusted fragment.
   fn is_unsafe_ci(ci: KConstantInfo) -> G {
     match ci {
       KConstantInfo.Axiom(_, _, u) => u,
       KConstantInfo.Defn(_, _, _, s, _) =>
         match s {
-          DefinitionSafety.Unsafe => 1,
-          _ => 0,
+          DefinitionSafety.Safe => 0,
+          _ => 1,
         },
       KConstantInfo.Thm(_, _, _) => 0,
       KConstantInfo.Opaque(_, _, _, u) => u,
       KConstantInfo.Quot(_, _, _) => 0,
-      KConstantInfo.Induct(_, _, _, _, _, u, _) => u,
-      KConstantInfo.Ctor(_, _, _, _, _, _, u) => u,
-      KConstantInfo.Rec(_, _, _, _, _, _, _, _, u, _) => u,
+      KConstantInfo.Induct(_, _, _, _, _, u, _, _) => u,
+      KConstantInfo.Ctor(_, _, _, _, _, _, _, u) => u,
+      KConstantInfo.Rec(_, _, _, _, _, _, _, _, u, _, _) => u,
     }
   }
 
-  -- Mirror: src/ix/kernel/check.rs Safe→Unsafe transitive rejection.
-  -- Walks every Const(idx, _) in `e`; returns 0 if any target const is
-  -- unsafe, 1 otherwise. Used only when the calling const is itself safe.
-  fn safe_refs_only(e: KExpr, top: List‹&KConstantInfo›) -> G {
+  -- Safe→Unsafe transitive rejection. Walks every Const(addr, _) in `e`;
+  -- returns 0 if any target const is unsafe, 1 otherwise. Used only when
+  -- the calling const is itself safe. Refs resolve via get_ci.
+  fn safe_refs_only(e: KExpr) -> G {
     match load(e) {
       KExprNode.BVar(_) => 1,
       KExprNode.Srt(_) => 1,
-      KExprNode.Const(idx, _) =>
-        let ci = load(list_lookup(top, idx));
+      KExprNode.Const(caddr, _) =>
+        let ci = load(get_ci(caddr));
         1 - is_unsafe_ci(ci),
       KExprNode.App(f, a) =>
-        safe_refs_only(f, top) * safe_refs_only(a, top),
+        safe_refs_only(f) * safe_refs_only(a),
       KExprNode.Lam(t, b) =>
-        safe_refs_only(t, top) * safe_refs_only(b, top),
+        safe_refs_only(t) * safe_refs_only(b),
       KExprNode.Forall(t, b) =>
-        safe_refs_only(t, top) * safe_refs_only(b, top),
+        safe_refs_only(t) * safe_refs_only(b),
       KExprNode.Let(t, v, b) =>
-        safe_refs_only(t, top) * safe_refs_only(v, top) * safe_refs_only(b, top),
+        safe_refs_only(t) * safe_refs_only(v) * safe_refs_only(b),
       KExprNode.Lit(_) => 1,
-      KExprNode.Proj(_, _, e1) => safe_refs_only(e1, top),
+      KExprNode.Proj(_, _, e1) => safe_refs_only(e1),
     }
   }
 
-  -- Assert that a Safe-classified const has no unsafe refs in `e`.
-  -- For unsafe-classified consts, this is a no-op.
-  fn assert_safety(self_unsafe: G, e: KExpr, top: List‹&KConstantInfo›) {
+  -- Assert a Safe-classified const has no unsafe refs in `e`.
+  -- For unsafe self, no-op.
+  fn assert_safety(self_unsafe: G, e: KExpr) {
     match self_unsafe {
       1 => (),
-      0 =>
-        let ok = safe_refs_only(e, top);
-        assert_eq!(ok, 1);
+      _ =>
+        assert_eq!(safe_refs_only(e), 1,
+          "safe constant references an unsafe constant");
         (),
     }
   }
 
-  -- Mirror: src/ix/kernel/check.rs:572-598 fn validate_univ_params_seen.
+  -- Mirror crates/kernel/src/check.rs fn validate_univ_params_seen.
   -- Walks a KLevel asserting `Param(i)` has `i < bound`. Aiur's `store`/
   -- `load` deduplication subsumes Rust's seen-set.
   fn validate_univ_params_seen(u: KLevel, bound: G) {
@@ -99,7 +107,8 @@ def check := ⟦
         validate_univ_params_seen(a, bound);
         validate_univ_params_seen(b, bound),
       KLevelNode.Param(i) =>
-        assert_eq!(u32_less_than(i, bound), 1);
+        assert_eq!(u32_less_than(i, bound), 1,
+          "universe param index out of range");
         (),
     }
   }
@@ -113,254 +122,3730 @@ def check := ⟦
     }
   }
 
-  -- Mirror: src/ix/kernel/check.rs:494-570 fn validate_expr_well_scoped.
-  -- Walks `e` checking `BVar(i) < depth`, Const universe-arity match, and
-  -- recurses into universes via `validate_univ_params_seen`.
-  fn validate_expr_well_scoped(e: KExpr, depth: G, bound: G,
-                                top: List‹&KConstantInfo›) {
+  -- Walk `e` checking BVar depth + Const universe arity + Sort
+  -- level params bounded. Recurses via `get_ci` on each Const.
+  fn validate_expr_well_scoped(e: KExpr, depth: G, bound: G) {
     match load(e) {
       KExprNode.BVar(i) =>
-        assert_eq!(u32_less_than(i, depth), 1);
+        assert_eq!(u32_less_than(i, depth), 1,
+          "loose bound variable: BVar index exceeds binder depth");
         (),
       KExprNode.Srt(l) => validate_univ_params_seen(l, bound),
-      KExprNode.Const(idx, lvls) =>
-        let ci = load(list_lookup(top, idx));
+      KExprNode.Const(addr, lvls) =>
+        let ci = load(get_ci(addr));
         let expected = const_num_lvls(ci);
-        assert_eq!(list_length(lvls), expected);
+        assert_eq!(list_length(lvls), expected,
+          "Const applied to wrong number of universe levels");
         validate_univ_params_list(lvls, bound),
       KExprNode.App(f, a) =>
-        validate_expr_well_scoped(f, depth, bound, top);
-        validate_expr_well_scoped(a, depth, bound, top),
+        validate_expr_well_scoped(f, depth, bound);
+        validate_expr_well_scoped(a, depth, bound),
       KExprNode.Lam(t, b) =>
-        validate_expr_well_scoped(t, depth, bound, top);
-        validate_expr_well_scoped(b, depth + 1, bound, top),
+        validate_expr_well_scoped(t, depth, bound);
+        validate_expr_well_scoped(b, depth + 1, bound),
       KExprNode.Forall(t, b) =>
-        validate_expr_well_scoped(t, depth, bound, top);
-        validate_expr_well_scoped(b, depth + 1, bound, top),
+        validate_expr_well_scoped(t, depth, bound);
+        validate_expr_well_scoped(b, depth + 1, bound),
       KExprNode.Let(t, v, b) =>
-        validate_expr_well_scoped(t, depth, bound, top);
-        validate_expr_well_scoped(v, depth, bound, top);
-        validate_expr_well_scoped(b, depth + 1, bound, top),
+        validate_expr_well_scoped(t, depth, bound);
+        validate_expr_well_scoped(v, depth, bound);
+        validate_expr_well_scoped(b, depth + 1, bound),
       KExprNode.Lit(_) => (),
-      KExprNode.Proj(_, _, val) =>
-        validate_expr_well_scoped(val, depth, bound, top),
+      KExprNode.Proj(_, _, e1) =>
+        validate_expr_well_scoped(e1, depth, bound),
     }
   }
 
-  -- Mirror: src/ix/kernel/check.rs:422-478 fn validate_const_well_scoped.
-  -- Validates type + variant-specific value/rules. Rec rules carry rhs each.
-  fn validate_const_well_scoped(ci: KConstantInfo, top: List‹&KConstantInfo›) {
-    let bound = const_num_lvls(ci);
-    let ty = const_type_of(ci);
-    validate_expr_well_scoped(ty, 0, bound, top);
-    match ci {
-      KConstantInfo.Defn(_, _, val, _, _) =>
-        validate_expr_well_scoped(val, 0, bound, top),
-      KConstantInfo.Thm(_, _, val) =>
-        validate_expr_well_scoped(val, 0, bound, top),
-      KConstantInfo.Opaque(_, _, val, _) =>
-        validate_expr_well_scoped(val, 0, bound, top),
-      KConstantInfo.Rec(_, _, _, _, _, _, rules, _, _, _) =>
-        validate_recr_rules(rules, bound, top),
-      _ => (),
-    }
+  -- Type-check one constant at `addr` given its KConstantInfo.
+  --  handles Axiom / Defn / Thm / Opaque / Quot. Ind/Ctor/Rec
+  -- deferred to .
+  fn quot_type_addr() -> Addr {
+    store([0xabu8, 0x68u8, 0x2cu8, 0x17u8, 0x78u8, 0xa1u8, 0x7bu8, 0xbeu8,
+     0xaeu8, 0x40u8, 0x32u8, 0x97u8, 0x4du8, 0xf3u8, 0x64u8, 0x47u8,
+     0xceu8, 0x8bu8, 0xfcu8, 0xabu8, 0x67u8, 0x64u8, 0xa3u8, 0x6du8,
+     0x37u8, 0x85u8, 0x66u8, 0xe3u8, 0xadu8, 0x63u8, 0xcau8, 0xb8u8])
   }
 
-  fn validate_recr_rules(rules: List‹KRecRule›, bound: G,
-                          top: List‹&KConstantInfo›) {
-    match load(rules) {
-      ListNode.Nil => (),
-      ListNode.Cons(rule, rest) =>
-        match rule {
-          KRecRule.Mk(_, _, rhs) =>
-            validate_expr_well_scoped(rhs, 0, bound, top);
-            validate_recr_rules(rest, bound, top),
+  fn quot_ctor_addr() -> Addr {
+    store([0x88u8, 0x26u8, 0x66u8, 0x77u8, 0xfeu8, 0xe7u8, 0x74u8, 0xd1u8,
+     0x09u8, 0x86u8, 0x7eu8, 0x4bu8, 0x22u8, 0x40u8, 0x28u8, 0x1au8,
+     0xa2u8, 0xeeu8, 0x12u8, 0xd9u8, 0x79u8, 0x20u8, 0xc1u8, 0x17u8,
+     0x1cu8, 0xf5u8, 0xc1u8, 0xf6u8, 0xc8u8, 0x7du8, 0xecu8, 0xf6u8])
+  }
+
+  fn quot_lift_addr() -> Addr {
+    store([0x8du8, 0xc4u8, 0xa9u8, 0x75u8, 0x27u8, 0x81u8, 0x2fu8, 0x8bu8,
+     0x78u8, 0x17u8, 0xb7u8, 0x7cu8, 0xd0u8, 0x79u8, 0xacu8, 0xe6u8,
+     0x14u8, 0x50u8, 0xaau8, 0x01u8, 0x85u8, 0xacu8, 0x58u8, 0x85u8,
+     0x66u8, 0x1eu8, 0xc2u8, 0xacu8, 0xbau8, 0x8bu8, 0x7bu8, 0xd0u8])
+  }
+
+  fn quot_ind_addr() -> Addr {
+    store([0x12u8, 0x49u8, 0x84u8, 0xbcu8, 0xb9u8, 0x52u8, 0x08u8, 0xa0u8,
+     0xf3u8, 0x0bu8, 0xb6u8, 0x9du8, 0x67u8, 0x36u8, 0xd3u8, 0xd5u8,
+     0x94u8, 0x04u8, 0xe1u8, 0x15u8, 0xe2u8, 0x20u8, 0x20u8, 0x43u8,
+     0xfdu8, 0xa3u8, 0xd3u8, 0x4eu8, 0x01u8, 0xb0u8, 0xadu8, 0x16u8])
+  }
+
+  -- Returns 1 iff `ty` has at least `n` leading Foralls.
+  fn count_foralls_at_least(ty: KExpr, n: G, seen: G) -> G {
+    match n - seen {
+      0 => 1,
+      _ =>
+        match load(ty) {
+          KExprNode.Forall(_, body) =>
+            count_foralls_at_least(body, n, seen + 1),
+          _ => 0,
         },
     }
   }
 
-  -- Mirror: src/ix/kernel/check.rs:678-720 fn check_eq_type.
-  -- Asserts the Eq inductive in `top` has 1 universe param, 2 params, and
-  -- exactly one ctor whose address matches `eq_refl_addr()`.
-  fn check_eq_type(top: List‹&KConstantInfo›, addrs: List‹Addr›) {
-    let eq_idx = find_addr_idx(eq_addr(), addrs, 0);
-    let eq_ci = load(list_lookup(top, eq_idx));
+  -- Mirror check_eq_type: assert Eq inductive shape (1 lvl, 2 params,
+  -- 1 ctor = Eq.refl). the kernel's KConstantInfo.Induct doesn't store
+  -- ctor_indices; we assert (num_lvls, n_params, num_ctors) then trust
+  -- the ctor identity check to fire when Eq.refl itself is checked as a
+  -- closure member (via check_ctor_return_type, which is  item 3).
+  -- Adversarial Eq → Quot.Lift unsound reduction only if Eq is also
+  -- forged in the closure; per-const gauntlet closes that.
+  fn check_eq_type() {
+    let eq_addr = store([0x03u8, 0x6bu8, 0x63u8, 0xd5u8, 0xccu8, 0x09u8, 0x61u8, 0xe9u8,
+                          0x20u8, 0xdeu8, 0xe5u8, 0x0eu8, 0x73u8, 0x64u8, 0xecu8, 0x0du8,
+                          0xd3u8, 0xf9u8, 0xc3u8, 0x8au8, 0x9cu8, 0xacu8, 0xe4u8, 0x0eu8,
+                          0x51u8, 0x3bu8, 0x38u8, 0x35u8, 0xdeu8, 0xc8u8, 0xe0u8, 0xc9u8]);
+    let eq_ci = load(get_ci(eq_addr));
     match eq_ci {
-      KConstantInfo.Induct(num_lvls, _, n_params, _, ctor_indices, _, _) =>
-        assert_eq!(num_lvls, 1);
-        assert_eq!(n_params, 2);
-        assert_eq!(list_length(ctor_indices), 1);
-        let ctor_pos = list_lookup(ctor_indices, 0);
-        let ctor_addr = list_lookup(addrs, ctor_pos);
-        assert_eq!(address_eq(ctor_addr, eq_refl_addr()), 1);
+      KConstantInfo.Induct(num_lvls, _, n_params, _, num_ctors, _, _, _) =>
+        assert_eq!(num_lvls, 1, "Eq inductive: wrong universe param count");
+        assert_eq!(n_params, 2, "Eq inductive: wrong parameter count");
+        assert_eq!(num_ctors, 1, "Eq inductive: wrong constructor count");
+        (),
+    }
+  }
+
+  -- Mirror check_quot: address ↔ kind consistency + (expected_lvls,
+  -- expected_foralls) per variant. Quot.Lift extra: Eq inductive
+  -- well-shaped.
+  fn check_quot(self_addr: Addr, kind: QuotKind,
+                    num_lvls: G, ty: KExpr) {
+    let pair = match kind {
+      QuotKind.Typ =>
+        assert_eq!(address_eq(self_addr, quot_type_addr()), 1,
+          "Quot.Typ declared at a non-canonical address");
+        (1, 2),
+      QuotKind.Ctor =>
+        assert_eq!(address_eq(self_addr, quot_ctor_addr()), 1,
+          "Quot.mk declared at a non-canonical address");
+        (1, 3),
+      QuotKind.Lift =>
+        assert_eq!(address_eq(self_addr, quot_lift_addr()), 1,
+          "Quot.lift declared at a non-canonical address");
+        check_eq_type();
+        (2, 6),
+      QuotKind.Ind =>
+        assert_eq!(address_eq(self_addr, quot_ind_addr()), 1,
+          "Quot.ind declared at a non-canonical address");
+        (1, 5),
+    };
+    match pair {
+      (expected_lvls, expected_foralls) =>
+        assert_eq!(num_lvls, expected_lvls,
+          "Quot constant: wrong universe param count for its kind");
+        assert_eq!(count_foralls_at_least(ty, expected_foralls, 0), 1,
+          "Quot constant: type has too few foralls for its kind");
         (),
     }
   }
 
   -- ============================================================================
-  -- check_const: dispatch per KConstantInfo variant.
+  -- Ctor gauntlet — the checks a constructor must survive.
+  --   check_ctor_return_type — assert the peeled body is headed by THIS
+  --     inductive (via assert_return_head_is_parent), with matching
+  --     universe params, the correct BVar param spine, and no index
+  --     argument mentioning the inductive block (index positivity).
+  --   check_param_agreement — walk n Foralls of both types, k_is_def_eq
+  --     each domain under accumulated types.
+  --   check_field_universes — post-params, each field domain's sort
+  --     level ≤ ind_level. Skipped for Prop inductives.
+  --   get_result_sort_level — peel n Foralls (whnf per step), return Sort's level.
   -- ============================================================================
-  fn check_const(ci: KConstantInfo, pos: G, top: List‹&KConstantInfo›, addrs: List‹Addr›) {
-    validate_const_well_scoped(ci, top);
-    let u = is_unsafe_ci(ci);
-    match ci {
-      KConstantInfo.Axiom(_, ty, _) =>
-        k_ensure_sort(ty, store(ListNode.Nil), top, addrs);
-        assert_safety(u, ty, top);
-        (),
 
-      KConstantInfo.Defn(_, ty, val, _, _) =>
-        k_ensure_sort(ty, store(ListNode.Nil), top, addrs);
-        assert_safety(u, ty, top);
-        assert_safety(u, val, top);
-        k_check(val, ty, store(ListNode.Nil), top, addrs);
-        (),
+  -- Peel `n` Foralls off the head, return the body. Panics if fewer
+  -- Foralls than requested.
+  fn peel_n_foralls(e: KExpr, n: G) -> KExpr {
+    match n {
+      0 => e,
+      _ =>
+        match load(e) {
+          KExprNode.Forall(_, body) => peel_n_foralls(body, n - 1),
+        },
+    }
+  }
 
-      KConstantInfo.Thm(_, ty, val) =>
-        -- Mirror: src/ix/kernel/check.rs:135. Theorem type must be Sort 0.
-        let lvl = k_ensure_sort(ty, store(ListNode.Nil), top, addrs);
-        assert_eq!(level_equal(lvl, store(KLevelNode.Zero)), 1);
-        assert_safety(u, ty, top);
-        assert_safety(u, val, top);
-        k_check(val, ty, store(ListNode.Nil), top, addrs);
-        (),
+  fn peel_n_lams(e: KExpr, n: G) -> KExpr {
+    match n {
+      0 => e,
+      _ =>
+        match load(e) {
+          KExprNode.Lam(_, body) => peel_n_lams(body, n - 1),
+        },
+    }
+  }
 
-      KConstantInfo.Opaque(_, ty, val, is_unsafe) =>
-        k_ensure_sort(ty, store(ListNode.Nil), top, addrs);
-        assert_safety(u, ty, top);
-        assert_safety(u, val, top);
-        match is_unsafe {
-          1 => (),
-          0 =>
-            k_check(val, ty, store(ListNode.Nil), top, addrs);
-            (),
+  -- Tolerant: peel up to n Lams, stop early on non-Lam.
+  fn peel_n_lams_tol(e: KExpr, n: G, peeled: G) -> (KExpr, G) {
+    match n {
+      0 => (e, peeled),
+      _ =>
+        match load(e) {
+          KExprNode.Lam(_, body) => peel_n_lams_tol(body, n - 1, peeled + 1),
+          _ => (e, peeled),
         },
+    }
+  }
 
-      KConstantInfo.Quot(num_lvls, ty, kind) =>
-        k_ensure_sort(ty, store(ListNode.Nil), top, addrs);
-        assert_safety(u, ty, top);
-        -- Mirror: src/ix/kernel/check.rs:606-675 fn check_quot.
-        -- Validate kind ↔ address consistency, universe-param count per
-        -- variant, and forall-binder count.
-        let self_addr = list_lookup(addrs, pos);
-        check_quot(self_addr, kind, num_lvls, ty, top, addrs);
+  -- Each `lvls[i]` must be `Param(expected_start + i)` for i in 0..count.
+  fn assert_lvls_are_params(lvls: List‹KLevel›, count: G, idx: G) {
+    match count {
+      0 =>
+        assert_eq!(list_length(lvls), 0,
+          "more universe levels than the inductive declares");
         (),
+      _ =>
+        match load(lvls) {
+          ListNode.Cons(l, rest) =>
+            match load(l) {
+              KLevelNode.Param(i) =>
+                assert_eq!(i, idx,
+                  "ctor return type: universe level is not Param(i) in order");
+                assert_lvls_are_params(rest, count - 1, idx + 1);
+                (),
+            },
+        },
+    }
+  }
+
+  -- The first `n_params` args of the spine must be exactly
+  -- `BVar(n_fields + n_params - 1 - i)` for i in 0..n_params, i.e. the
+  -- de Bruijn references to the param binders peeled off the ctor's
+  -- type. The remaining args are the indices — those are unrestricted
+  -- here (per Rust 2046+).
+  fn assert_first_args_are_param_bvars(args: List‹KExpr›,
+                                            n_params: G, n_fields: G, i: G) {
+    match n_params - i {
+      0 => (),
+      _ =>
+        match load(args) {
+          ListNode.Cons(arg, rest) =>
+            match load(arg) {
+              KExprNode.BVar(j) =>
+                assert_eq!(j, ((n_fields + n_params) - 1) - i,
+                  "ctor return type: param arg is not the expected param BVar");
+                assert_first_args_are_param_bvars(rest, n_params, n_fields, i + 1);
+                (),
+            },
+        },
+    }
+  }
 
-      KConstantInfo.Induct(_, ty, n_params, n_indices, _,
-                          _, block_addr) =>
-        k_ensure_sort(ty, store(ListNode.Nil), top, addrs);
-        assert_safety(u, ty, top);
-        check_block_peer_param_agreement(pos, ty, n_params, n_indices,
-                                                  block_addr, top, addrs);
-        -- Self-contained inductive validation: result sort + the full
-        -- per-ctor gauntlet (param agreement, return type, field
-        -- universes, positivity). Without it, subject-only checking
-        -- (arena `verify_const`) accepts an inductive whose badness
-        -- lives in a ctor const. Mirror: check_inductive_member walks
-        -- its ctors.
-        check_inductive_shape(pos, top, addrs);
-        -- NOTE: stored Muts blocks never contain aux inductives — nested
-        -- auxes are discovered transiently (mirror: inductive.rs seeds every
-        -- stored member `is_aux: false`, rs:537, and flags auxes only on
-        -- detection, rs:755). A stored-aux validation pass here would have
-        -- nothing legitimate to match; smuggled extra members are rejected
-        -- by the recursor-vs-canonical-type equality, whose canonical types
-        -- are built over the detected flat block.
-        -- The former H1 declared-vs-computed is_rec check is gone with the
-        -- Ixon recr flag: there is no declared value to verify. is_rec is
-        -- computed on demand (`computed_is_rec_ind`) wherever it matters
-        -- (struct-eta / unit-like gates), so an adversary has nothing to
-        -- forge. Mirror: check_inductive after `Ixon: drop recr/refl/nested`.
+  -- Mirror crates/kernel/src/inductive.rs check_ctor_return_type.
+  -- Validates that a ctor's declared type, after peeling
+  -- `n_params + n_fields` Foralls, is a syntactic `Indc(params, indices)`
+  -- application:
+  -- * head is `Const(ind_idx, lvls)`
+  -- * `lvls.len() == ind_num_lvls`
+  -- * each `lvls[i]` is `Param(i)`
+  -- * spine args count is `n_params + n_indices`
+  -- * first `n_params` args are the param BVars (de Bruijn equivalents
+  -- of Rust's param fvars at line 1986-1994).
+  --
+  -- Shapes that cannot occur have no match arm at all: an unmatched value
+  -- aborts the Aiur execution, which is the kernel's reject. An arm whose
+  -- only job is to fail is strictly worse — it widens the circuit on every
+  -- row to buy an error message on a path that rejects either way.
+  --
+  -- The peeled return head must be THIS inductive: its KCI must be an
+  -- Induct stored at (block_addr, ind_idx). Without it the head is
+  -- constrained only to be SOME Const of matching universe arity, so a
+  -- ctor of `I` may declare `mk : ... -> J params indices` for a
+  -- different `J` — e.g. a mutual peer. `check_param_agreement` does not
+  -- cover this: it compares only the first `n_params` forall domains and
+  -- says nothing about the return head.
+  fn assert_return_head_is_parent(caddr: Addr, block_addr: Addr,
+                                       ind_idx: G) {
+    let ci = load(get_ci(caddr));
+    match ci {
+      KConstantInfo.Induct(_, _, _, _, _, _, ba, ii) =>
+        assert_eq!(address_eq(ba, block_addr), 1,
+          "ctor return head belongs to a different block");
+        assert_eq!(ii, ind_idx,
+          "ctor return head is a different member of the block");
         (),
+    }
+  }
 
-      -- Ctor cross-ref + return-type + field-universe + strict-positivity
-      -- (positivity walks mutual + nested via derive_block_member_idxs).
-      KConstantInfo.Ctor(_, ty, induct_idx, _, num_params, num_fields, _) =>
-        k_ensure_sort(ty, store(ListNode.Nil), top, addrs);
-        assert_safety(u, ty, top);
-        check_ctor_against_inductive_member(pos, ci, top);
-        let ind_ci = load(list_lookup(top, induct_idx));
-        match ind_ci {
-          KConstantInfo.Induct(ind_num_lvls, ind_ty, ind_n_params, ind_n_indices, _, _, _) =>
-            assert_eq!(num_params, ind_n_params);
-            -- A1 defense-in-depth: ctor's leading param domains must match
-            -- parent inductive's. Mirror src/ix/kernel/inductive.rs:283,393.
-            check_param_agreement(ind_ty, ty, ind_n_params, top, addrs);
-            check_ctor_return_type(ty, num_params, ind_n_indices, num_fields,
-                                           induct_idx, ind_num_lvls, top);
-            let ind_level = get_result_sort_level(ind_ty, ind_n_params + ind_n_indices,
-                                                  store(ListNode.Nil), top, addrs);
-            check_field_universes(ty, num_params, ind_level,
-                                          store(ListNode.Nil), top, addrs);
-            check_positivity(ty, num_params, induct_idx, store(ListNode.Nil), top, addrs);
+  fn check_ctor_return_type(ctor_ty: KExpr, n_params: G,
+                                 n_indices: G, n_fields: G,
+                                 ind_num_lvls: G, block_addr: Addr,
+                                 ind_idx: G) {
+    let body = peel_n_foralls(ctor_ty, n_params + n_fields);
+    match collect_spine(body) {
+      (head, args) =>
+        match load(head) {
+          KExprNode.Const(head_addr, lvls) =>
+            assert_return_head_is_parent(head_addr, block_addr, ind_idx);
+            assert_lvls_are_params(lvls, ind_num_lvls, 0);
+            assert_eq!(list_length(args), n_params + n_indices,
+              "ctor return type: wrong number of spine arguments");
+            assert_first_args_are_param_bvars(args, n_params, n_fields, 0);
+            -- Index args must not mention block inductives — rejects
+            -- `mk : I (I x)`, a reflexive occurrence in INDEX position.
+            -- Field positions are covered by check_positivity; a ctor
+            -- with zero fields has none, so this is the only gate that
+            -- sees it. Mirror Inductive.lean:52-56.
+            let idx_args = list_drop(args, n_params);
+            let block_addrs = store(ListNode.Cons(block_addr,
+                                                   store(ListNode.Nil)));
+            assert_eq!(list_any_mentions_block(idx_args, block_addrs), 0,
+              "ctor return type: reflexive occurrence in an index argument");
             (),
         },
+    }
+  }
 
-      KConstantInfo.Rec(_, ty, _, _, _, _, _, _, _, _) =>
-        k_ensure_sort(ty, store(ListNode.Nil), top, addrs);
-        assert_safety(u, ty, top);
-        check_recursor_member(pos, ci, top, addrs);
-        (),
+  fn check_param_agreement_go(ta: KExpr, tb: KExpr, n: G,
+                                   types: List‹KExpr›) {
+    match n {
+      0 => (),
+      _ =>
+        match load(ta) {
+          KExprNode.Forall(da, ba) =>
+            match load(tb) {
+              KExprNode.Forall(db, bb) =>
+                let eq = k_is_def_eq(da, db, types);
+                assert_eq!(eq, 1,
+                  "ctor parameter type disagrees with the inductive's");
+                let inner = store(ListNode.Cons(da, types));
+                check_param_agreement_go(ba, bb, n - 1, inner),
+            },
+        },
     }
   }
 
-  -- Mirror: src/ix/kernel/check.rs:606-675 fn check_quot.
-  -- Validates quot variant consistency: address ↔ kind match, universe
-  -- param count, and at-least-N forall binders for the type.
-  fn check_quot(self_addr: Addr, kind: QuotKind, num_lvls: G, ty: KExpr,
-                 top: List‹&KConstantInfo›, addrs: List‹Addr›) {
-    -- Address ↔ kind consistency + per-variant (lvls, foralls) expectations.
-    -- Type/Ctor/Ind = 1 lvl; Lift = 2 lvls.
-    -- Foralls: Type=2, Ctor=3, Lift=6, Ind=5.
-    let pair = match kind {
-      QuotKind.Typ =>
-        assert_eq!(address_eq(self_addr, quot_type_addr()), 1);
-        (1, 2),
-      QuotKind.Ctor =>
-        assert_eq!(address_eq(self_addr, quot_ctor_addr()), 1);
-        (1, 3),
-      QuotKind.Lift =>
-        assert_eq!(address_eq(self_addr, quot_lift_addr()), 1);
-        -- Mirror: src/ix/kernel/check.rs:651-653. Lift requires Eq type
-        -- to be properly formed (Quot.lift uses Eq in its reduction rule).
-        check_eq_type(top, addrs);
-        (2, 6),
-      QuotKind.Ind =>
-        assert_eq!(address_eq(self_addr, quot_ind_addr()), 1);
-        (1, 5),
-    };
-    match pair {
-      (expected_lvls, expected_foralls) =>
-        assert_eq!(num_lvls, expected_lvls);
-        assert_eq!(count_foralls_at_least(ty, expected_foralls, 0), 1);
-        (),
+  -- Walk first n Foralls of both types asserting domain def-eq under the
+  -- accumulated param-binder context.
+  fn check_param_agreement(ta: KExpr, tb: KExpr, n: G) {
+    check_param_agreement_go(ta, tb, n, store(ListNode.Nil))
+  }
+
+  -- Peel n (params + indices) Foralls; body must be Srt(l). Returns l.
+  -- whnf per step: index binders can hide under defs.
+  fn get_result_sort_level(ind_ty: KExpr, n: G,
+                                types: List‹KExpr›) -> KLevel {
+    let w = whnf(ind_ty, types);
+    match n {
+      0 =>
+        match load(w) {
+          KExprNode.Srt(l) => l,
+        },
+      _ =>
+        match load(w) {
+          KExprNode.Forall(dom, body) =>
+            get_result_sort_level(body, n - 1,
+              store(ListNode.Cons(dom, types))),
+        },
     }
   }
 
-  -- Returns 1 iff `ty` has at least `n` leading Foralls.
-  fn count_foralls_at_least(ty: KExpr, n: G, seen: G) -> G {
-    match n - seen {
-      0 => 1,
+  fn check_field_universes_inner(ty: KExpr, ind_level: KLevel,
+                                      types: List‹KExpr›) {
+    match load(ty) {
+      KExprNode.Forall(dom, body) =>
+        let dom_level = k_ensure_sort(dom, types);
+        assert_eq!(level_leq(dom_level, ind_level), 1,
+          "ctor field lives in a universe above the inductive's");
+        check_field_universes_inner(body, ind_level,
+          store(ListNode.Cons(dom, types))),
+      _ => (),
+    }
+  }
+
+  fn check_field_universes_skip_params(ctor_ty: KExpr, n_params: G,
+                                            ind_level: KLevel,
+                                            types: List‹KExpr›) {
+    match n_params {
+      0 => check_field_universes_inner(ctor_ty, ind_level, types),
+      _ =>
+        match load(ctor_ty) {
+          KExprNode.Forall(dom, body) =>
+            check_field_universes_skip_params(body, n_params - 1,
+              ind_level, store(ListNode.Cons(dom, types))),
+        },
+    }
+  }
+
+  -- Skipped for Prop (ind_level = Zero).
+  fn check_field_universes(ctor_ty: KExpr, n_params: G,
+                                 ind_level: KLevel) {
+    match load(ind_level) {
+      KLevelNode.Zero => (),
+      _ => check_field_universes_skip_params(ctor_ty, n_params,
+                                                  ind_level, store(ListNode.Nil)),
+    }
+  }
+
+  -- Fetch a constructor's parent inductive KCI. A Ctor stores its parent
+  -- as (block_addr, ind_idx) rather than a direct addr, so resolution
+  -- goes through the block's inductive projection wrapper.
+  fn ctor_parent_ind_ci(block_addr: Addr, ind_idx: G)
+                              -> &KConstantInfo {
+    get_ci_iprj(block_addr, ind_idx)
+  }
+
+  -- ============================================================================
+  -- Strict positivity.
+  --
+  -- Block membership is tracked by block_addr: a `Const(caddr, _)` is a
+  -- peer of block_addr iff its KCI is an Inductive whose stored
+  -- block_addr equals ours. Standalone inductives use their own addr as
+  -- block_addr, so the same test covers both cases.
+  --
+  -- block_addrs: List<Addr> starts as the singleton [outer]
+  -- (`check_positivity`) and is extended with a nested inductive's own
+  -- block each time `check_positivity_aug` descends into it, so an
+  -- occurrence is negative if it hits ANY enclosing block, not just the
+  -- innermost. That growth is also what makes the descent terminate —
+  -- see `check_nested_ctors_positivity`.
+  -- ============================================================================
+
+  fn addr_list_contains(xs: List‹Addr›, target: Addr) -> G {
+    match load(xs) {
+      ListNode.Nil => 0,
+      ListNode.Cons(a, rest) =>
+        match address_eq(a, target) {
+          1 => 1,
+          _ => addr_list_contains(rest, target),
+        },
+    }
+  }
+
+  -- Query: does `caddr`'s KCI classify it as a peer inductive of any
+  -- block in block_addrs? A Const is a peer iff its KCI is Induct AND its
+  -- stored block_addr matches (mutual peer).
+  fn caddr_is_peer(caddr: Addr, block_addrs: List‹Addr›) -> G {
+    let ci = load(get_ci(caddr));
+    match ci {
+      KConstantInfo.Induct(_, _, _, _, _, _, ba, _) =>
+        addr_list_contains(block_addrs, ba),
+      _ => 0,
+    }
+  }
+
+  fn expr_mentions_block(e: KExpr, block_addrs: List‹Addr›) -> G {
+    match load(e) {
+      KExprNode.BVar(_) => 0,
+      KExprNode.Srt(_) => 0,
+      KExprNode.Const(caddr, _) => caddr_is_peer(caddr, block_addrs),
+      KExprNode.App(f, a) =>
+        match expr_mentions_block(f, block_addrs) {
+          1 => 1,
+          _ => expr_mentions_block(a, block_addrs),
+        },
+      KExprNode.Lam(t, b) =>
+        match expr_mentions_block(t, block_addrs) {
+          1 => 1,
+          _ => expr_mentions_block(b, block_addrs),
+        },
+      KExprNode.Forall(t, b) =>
+        match expr_mentions_block(t, block_addrs) {
+          1 => 1,
+          _ => expr_mentions_block(b, block_addrs),
+        },
+      KExprNode.Let(t, v, b) =>
+        match expr_mentions_block(t, block_addrs) {
+          1 => 1,
+          _ =>
+            match expr_mentions_block(v, block_addrs) {
+              1 => 1,
+              _ => expr_mentions_block(b, block_addrs),
+            },
+        },
+      KExprNode.Lit(_) => 0,
+      KExprNode.Proj(_, _, e1) => expr_mentions_block(e1, block_addrs),
+    }
+  }
+
+  fn list_any_mentions_block(es: List‹KExpr›,
+                                  block_addrs: List‹Addr›) -> G {
+    match load(es) {
+      ListNode.Nil => 0,
+      ListNode.Cons(e, rest) =>
+        match expr_mentions_block(e, block_addrs) {
+          1 => 1,
+          _ => list_any_mentions_block(rest, block_addrs),
+        },
+    }
+  }
+
+  -- Like `peel_n_foralls_tolerant` but accumulates each binder's domain into
+  -- the types context so subsequent WHNF calls have the right local context.
+  fn peel_n_foralls_with_types(e: KExpr, n: G,
+                                    types: List‹KExpr›) -> (KExpr, List‹KExpr›) {
+    match n {
+      0 => (e, types),
+      _ =>
+        match load(e) {
+          KExprNode.Forall(dom, body) =>
+            let t2 = store(ListNode.Cons(dom, types));
+            peel_n_foralls_with_types(body, n - 1, t2),
+          _ => (e, types),
+        },
+    }
+  }
+
+  -- Positivity check on one field's domain type.
+  -- If dom doesn't mention any block member, trivially positive.
+  -- If it does, whnf and inspect: a Forall with block-mentioning-body
+  -- must NOT mention block in its own domain (else negative occurrence);
+  -- an inductive spine head must be either a peer (block member — OK
+  -- direct occurrence) or a nested inductive whose non-param args don't
+  -- mention block.
+  fn check_positivity_aug(dom: KExpr, block_addrs: List‹Addr›,
+                               types: List‹KExpr›) {
+    match expr_mentions_block(dom, block_addrs) {
+      0 => (),
+      _ =>
+        let dom_w = whnf(dom, types);
+        match load(dom_w) {
+          KExprNode.Forall(idom, ibody) =>
+            assert_eq!(expr_mentions_block(idom, block_addrs), 0,
+              "strict positivity: block occurs left of an arrow");
+            let t2 = store(ListNode.Cons(idom, types));
+            check_positivity_aug(ibody, block_addrs, t2),
+          _ =>
+            match collect_spine(dom_w) {
+              (head, args) =>
+                match load(head) {
+                  KExprNode.Const(caddr, _) =>
+                    match caddr_is_peer(caddr, block_addrs) {
+                      1 => (),
+                      _ =>
+                        let ci = load(get_ci(caddr));
+                        match ci {
+                          KConstantInfo.Induct(_, _, n_ctor_params,
+                                                 _, ext_num_ctors, _,
+                                                 ext_block_addr, ext_ind_idx) =>
+                            let after_params = list_drop(args, n_ctor_params);
+                            assert_eq!(list_any_mentions_block(after_params,
+                                                                    block_addrs), 0,
+                              "strict positivity: block occurs in a nested inductive's index args");
+                            -- Descend into the NESTED inductive's own
+                            -- constructors under an augmented block set.
+                            -- Without this, `Host | mk : Bad2 -> Host` is
+                            -- accepted whenever `Bad2 | mk : (Bad2 -> Empty)
+                            -- -> Bad2` is itself never checked — the
+                            -- negative occurrence lives inside the ext, not
+                            -- in Host's own field.
+                            --
+                            -- Terminates because `aug` only grows: a field
+                            -- mentioning an already-tracked block hits the
+                            -- `caddr_is_peer` arm above and stops, and the
+                            -- number of distinct reachable blocks is finite.
+                            let aug = store(ListNode.Cons(ext_block_addr,
+                                                              block_addrs));
+                            let rev_params = list_reverse(
+                              list_take(args, n_ctor_params));
+                            check_nested_ctors_positivity(ext_block_addr,
+                              ext_ind_idx, ext_num_ctors, aug, 0,
+                              n_ctor_params, rev_params),
+                        },
+                    },
+                },
+            },
+        },
+    }
+  }
+
+  -- Walk every constructor of the nested inductive at
+  -- (block_addr, ind_idx), checking its fields under the augmented block
+  -- set. The ctors are reached by index through the block's projection
+  -- wrappers.
+  -- `rev_params` are the nested inductive's actual parameter ARGUMENTS,
+  -- reversed, and `n_params` is how many there are.
+  --
+  -- Substituting them is what makes this check mean anything. A nested
+  -- constructor's fields mention the inductive's parameters as bound
+  -- variables, so descending into the raw declared type asks whether the
+  -- block occurs in `BVar 0` — it never does, and every parameter
+  -- position passes vacuously. The occurrence being hunted lives in the
+  -- ARGUMENT that was substituted for that parameter. Concretely, for
+  -- `Inner α | mk : (α → False) → Inner α` used as `Inner Host`, the
+  -- negative occurrence of `Host` only appears once `α := Host`.
+  --
+  -- Mirrors `check_nested_ctor_fields` (crates/kernel/src/inductive.rs):
+  -- strip `n_params` foralls, then simultaneously substitute at depth 0.
+  -- After stripping, `BVar 0` is the LAST (innermost) parameter, so the
+  -- argument list is reversed — `expr_inst_many` maps `substs[i]` to
+  -- `BVar(depth + i)`, the same convention as `simul_subst`.
+  fn check_nested_ctors_positivity(block_addr: Addr, ind_idx: G,
+                                        num_ctors: G, aug: List‹Addr›,
+                                        cidx: G, n_params: G,
+                                        rev_params: List‹KExpr›) {
+    match num_ctors - cidx {
+      0 => (),
+      _ =>
+        let ctor_ci = load(get_ci_cprj(block_addr, ind_idx, cidx));
+        match ctor_ci {
+          KConstantInfo.Ctor(_, ctor_ty, _, _, _, _, _, _) =>
+            match peel_n_foralls_with_types(ctor_ty, n_params,
+                                                 store(ListNode.Nil)) {
+              (body, _) =>
+                -- Parameters are substituted away, so the field walk
+                -- starts with no binders in scope.
+                check_positivity_fields(expr_inst_many(body, rev_params, 0),
+                  aug, store(ListNode.Nil));
+                check_nested_ctors_positivity(block_addr, ind_idx,
+                  num_ctors, aug, cidx + 1, n_params, rev_params),
+            },
+        },
+    }
+  }
+
+  fn check_positivity_fields(ty: KExpr, block_addrs: List‹Addr›,
+                                  types: List‹KExpr›) {
+    match load(ty) {
+      KExprNode.Forall(dom, body) =>
+        check_positivity_aug(dom, block_addrs, types);
+        let t2 = store(ListNode.Cons(dom, types));
+        check_positivity_fields(body, block_addrs, t2),
+      _ => (),
+    }
+  }
+
+  -- Mirror crates/kernel/src/inductive.rs check_positivity.
+  -- Strict positivity: each ctor field's domain must not have any inductive
+  -- of `ind_idx`'s mutual block in a negative position (left of an arrow).
+  -- For mutual blocks, the initial positivity context is the full set of
+  -- peer inductive idxs (derived via block_addr). Nested inductives are
+  -- handled by augment_block_idxs walking ctor bodies recursively.
+  fn check_positivity(ctor_ty: KExpr, n_params: G,
+                          block_addr: Addr, types: List‹KExpr›) {
+    let block_addrs = store(ListNode.Cons(block_addr, store(ListNode.Nil)));
+    match peel_n_foralls_with_types(ctor_ty, n_params, types) {
+      (body, types_after) =>
+        check_positivity_fields(body, block_addrs, types_after),
+    }
+  }
+
+  -- Mirror Inductive.lean:73 check_inductive_shape.
+  --
+  -- Self-contained inductive validation: the inductive's own type must
+  -- peel params+indices to a Sort, and EVERY constructor of the block
+  -- runs the full gauntlet (identity, param agreement, return type,
+  -- field universes, positivity).
+  --
+  -- Load-bearing for subject-only checking: an inductive whose badness
+  -- lives in a ctor (negative occurrence, wrong ctor params, bad field
+  -- universe) is only rejected if checking the INDUCTIVE walks its
+  -- ctors. Without this the arena `verify_const` fixtures indNeg /
+  -- inductWrongCtorParams / reflOccLeft / … are silently accepted.
+  -- Ctors resolve through get_ci_cprj (memoized), so a block's
+  -- shape check costs one pass regardless of how many members ask.
+  fn check_inductive_shape(ty: KExpr, n_params: G, n_indices: G,
+                                num_ctors: G, num_lvls: G,
+                                block_addr: Addr, ind_idx: G) {
+    let ind_level = get_result_sort_level(ty, n_params + n_indices,
+                                               store(ListNode.Nil));
+    check_inductive_shape_ctors(ty, n_params, n_indices, num_ctors,
+                                     num_lvls, block_addr, ind_idx,
+                                     ind_level, 0)
+  }
+
+  fn check_inductive_shape_ctors(ind_ty: KExpr, n_params: G,
+                                      n_indices: G, num_ctors: G,
+                                      num_lvls: G, block_addr: Addr,
+                                      ind_idx: G, ind_level: KLevel,
+                                      cidx: G) {
+    match num_ctors - cidx {
+      0 => (),
+      _ =>
+        let ctor_ci = load(get_ci_cprj(block_addr, ind_idx, cidx));
+        match ctor_ci {
+          KConstantInfo.Ctor(_, cty, c_block, c_ind_idx, c_cidx,
+                              c_np, c_nf, _) =>
+            -- Identity: the ctor must point back at THIS inductive, at
+            -- the position we asked for.
+            assert_eq!(address_eq(c_block, block_addr), 1,
+              "ctor belongs to a different block than its inductive");
+            assert_eq!(c_ind_idx, ind_idx,
+              "ctor points at a different member of the block");
+            assert_eq!(c_cidx, cidx,
+              "ctor's stored index differs from its position");
+            assert_eq!(c_np, n_params,
+              "ctor parameter count differs from the inductive's");
+            check_param_agreement(ind_ty, cty, n_params);
+            check_ctor_return_type(cty, c_np, n_indices, c_nf, num_lvls,
+                                        block_addr, ind_idx);
+            check_field_universes(cty, c_np, ind_level);
+            check_positivity(cty, c_np, block_addr, store(ListNode.Nil));
+            check_inductive_shape_ctors(ind_ty, n_params, n_indices,
+                                             num_ctors, num_lvls,
+                                             block_addr, ind_idx,
+                                             ind_level, cidx + 1),
+        },
+    }
+  }
+
+  -- Run the inductive shape gauntlet on an already-loaded Induct KCI.
+  -- Used by the Rec arm, where the parent inductive is resolved from
+  -- the recursor's motive spine rather than from check_const's subject.
+  fn check_parent_inductive_shape(ind_ci: KConstantInfo) {
+    match ind_ci {
+      KConstantInfo.Induct(nlvls, ty, n_params, n_indices, num_ctors,
+                            _, block_addr, ind_idx) =>
+        check_inductive_shape(ty, n_params, n_indices, num_ctors,
+                                   nlvls, block_addr, ind_idx),
+      _ => (),
+    }
+  }
+
+  -- Mirror Inductive.lean:3330-3378 check_block_peer_param_agreement.
+  -- Solo (block_addr == self addr) is no-op. For Muts blocks, walk
+  -- member list; for each Indc at position != self_ind_idx, resolve
+  -- via get_ci_iprj (memoized) and:
+  --   * n_params must match self's.
+  --   * First n_params leading Foralls' domains def-eq via
+  --     check_param_agreement.
+  --   * Result-universe (post params+indices) equal.
+  fn check_block_peer_param_agreement(ind_ci: KConstantInfo, addr: Addr) {
+    match ind_ci {
+      KConstantInfo.Induct(_, self_ty, self_np, self_ni, _, _,
+                             block_addr, self_ind_idx) =>
+        match address_eq(block_addr, addr) {
+          1 => (),
+          _ =>
+            let block_c = load_verified_constant(block_addr);
+            match block_c {
+              Constant.Mk(info, _, _, _) =>
+                match info {
+                  ConstantInfo.Muts(members) =>
+                    peer_agree_walk(members, self_ty, self_np, self_ni,
+                                         self_ind_idx, 0, block_addr),
+                  _ => (),
+                },
+            },
+        },
+      _ => (),
+    }
+  }
+
+  fn peer_agree_walk(members: List‹MutConst›, self_ty: KExpr,
+                          self_np: G, self_ni: G,
+                          self_ind_idx: G, pos: G, block_addr: Addr) {
+    match load(members) {
+      ListNode.Nil => (),
+      ListNode.Cons(m, rest) =>
+        match m {
+          MutConst.Indc(_) =>
+            let is_self = eq_zero(pos - self_ind_idx);
+            match is_self {
+              1 =>
+                peer_agree_walk(rest, self_ty, self_np, self_ni,
+                                     self_ind_idx, pos + 1, block_addr),
+              _ =>
+                let peer_ci = load(get_ci_iprj(block_addr, pos));
+                match peer_ci {
+                  KConstantInfo.Induct(_, peer_ty, peer_np, peer_ni,
+                                         _, _, _, _) =>
+                    assert_eq!(peer_np, self_np,
+                      "mutual block peers disagree on parameter count");
+                    check_param_agreement(self_ty, peer_ty, self_np);
+                    let self_lvl = get_result_sort_level(self_ty,
+                      self_np + self_ni, store(ListNode.Nil));
+                    let peer_lvl = get_result_sort_level(peer_ty,
+                      peer_np + peer_ni, store(ListNode.Nil));
+                    assert_eq!(level_equal(self_lvl, peer_lvl), 1,
+                      "mutual block peers land in different universes");
+                    peer_agree_walk(rest, self_ty, self_np, self_ni,
+                                         self_ind_idx, pos + 1, block_addr),
+                  _ =>
+                    peer_agree_walk(rest, self_ty, self_np, self_ni,
+                                         self_ind_idx, pos + 1, block_addr),
+                },
+            },
+          _ =>
+            peer_agree_walk(rest, self_ty, self_np, self_ni,
+                                 self_ind_idx, pos + 1, block_addr),
+        },
+    }
+  }
+
+  -- Large-eliminator classification. Returns 1 if the inductive with
+  -- (result_level, num_ctors, and if num_ctors=1 its lone ctor) can
+  -- target any universe; 0 if it must target Prop.
+  -- Takes the single ctor's KCI directly rather than looking it up — the
+  -- caller already resolved it via get_ci_cprj.
+  fn is_large_eliminator(result_level: KLevel, num_ctors: G,
+                              single_ctor_opt: (G, KConstantInfo))
+                              -> G {
+    match level_is_not_zero(result_level) {
+      1 => 1,
+      _ =>
+        match num_ctors {
+          0 => 1,
+          1 =>
+            match single_ctor_opt {
+              (present, ctor_ci) =>
+                match present {
+                  0 => 0,
+                  _ =>
+                    match ctor_ci {
+                      KConstantInfo.Ctor(_, ctor_ty, _, _, _, n_params,
+                                            n_fields, _) =>
+                        match n_fields {
+                          0 => 1,
+                          _ => check_large_prop_ctor(ctor_ty, n_params,
+                                                          n_fields,
+                                                          store(ListNode.Nil)),
+                        },
+                      _ => 0,
+                    },
+                },
+            },
+          _ => 0,
+        },
+    }
+  }
+
+  -- Mirror crates/kernel/src/inductive.rs large-elim check on Prop
+  -- single-ctor inductive. Walk past `n_params` Foralls (skipping params),
+  -- then walk `n_fields` Foralls collecting de Bruijn indices of data fields
+  -- (those whose domain has sort != 0). Body after walk is the ctor's return
+  -- type; check each data field's BVar appears in the return-type's spine
+  -- args. If all do → large eliminator.
+  fn check_large_prop_ctor(ty: KExpr, n_params: G, n_fields: G,
+                                types: List‹KExpr›) -> G {
+    match n_params {
+      0 =>
+        check_large_walk_fields(ty, n_fields, 0, types,
+                                     store(ListNode.Nil)),
       _ =>
         match load(ty) {
-          KExprNode.Forall(_, body) => count_foralls_at_least(body, n, seen + 1),
+          KExprNode.Forall(dom, body) =>
+            let inner = store(ListNode.Cons(dom, types));
+            check_large_prop_ctor(body, n_params - 1, n_fields, inner),
           _ => 0,
         },
     }
   }
 
-  fn check_all(consts: List‹&KConstantInfo›, top: List‹&KConstantInfo›, addrs: List‹Addr›) {
-    check_canonical_block_sort(top, addrs);
-    check_all_iter(consts, top, addrs, 0)
+  -- Walk `n_fields` Foralls, threading list of data-field BVars (de Bruijn
+  -- indices in the post-walk ret context). After walk, collect ret spine
+  -- args and verify every data BVar appears.
+  fn check_large_walk_fields(ty: KExpr, n_fields: G, field_idx: G,
+                                  types: List‹KExpr›,
+                                  data_bvars: List‹G›) -> G {
+    match n_fields - field_idx {
+      0 =>
+        match collect_spine(ty) {
+          (_, args) => all_bvars_in_args(data_bvars, args),
+        },
+      _ =>
+        match load(ty) {
+          KExprNode.Forall(dom, body) =>
+            let lvl = k_ensure_sort(dom, types);
+            let is_data = 1 - level_equal(lvl, store(KLevelNode.Zero));
+            -- Parenthesized: Aiur `-` is right-associative, so the bare
+            -- `n_fields - 1 - field_idx` reads as `n_fields - (1 - field_idx)`
+            -- and is correct only at field_idx = 0. At field_idx = 1 it
+            -- yields `n_fields` — the last param BVar, which the return
+            -- spine is guaranteed to contain — so a data field that never
+            -- appears in the return indices was counted as if it did, and
+            -- the inductive was classified large-eliminating when it is not.
+            let bvar_idx = (n_fields - 1) - field_idx;
+            let new_bvars = match is_data {
+              0 => data_bvars,
+              _ => store(ListNode.Cons(bvar_idx, data_bvars)),
+            };
+            let inner = store(ListNode.Cons(dom, types));
+            check_large_walk_fields(body, n_fields, field_idx + 1,
+                                          inner, new_bvars),
+          _ => 0,
+        },
+    }
   }
 
-  fn check_all_iter(consts: List‹&KConstantInfo›, top: List‹&KConstantInfo›,
-                    addrs: List‹Addr›, pos: G) {
-    match load(consts) {
-      ListNode.Nil => (),
-      ListNode.Cons(&ci, rest) =>
-        check_const(ci, pos, top, addrs);
-        check_all_iter(rest, top, addrs, pos + 1),
+  -- Returns 1 iff every BVar idx in `bvars` appears in `args` (as a syntactic
+  -- BVar at the ret-binder depth).
+  fn all_bvars_in_args(bvars: List‹G›, args: List‹KExpr›) -> G {
+    match load(bvars) {
+      ListNode.Nil => 1,
+      ListNode.Cons(b, rest) =>
+        match args_contain_bvar(args, b) {
+          0 => 0,
+          _ => all_bvars_in_args(rest, args),
+        },
+    }
+  }
+
+  -- Returns 1 if any element of `args` is syntactically `BVar(target)`.
+  fn args_contain_bvar(args: List‹KExpr›, target: G) -> G {
+    match load(args) {
+      ListNode.Nil => 0,
+      ListNode.Cons(a, rest) =>
+        match load(a) {
+          KExprNode.BVar(i) =>
+            match i - target {
+              0 => 1,
+              _ => args_contain_bvar(rest, target),
+            },
+          _ => args_contain_bvar(rest, target),
+        },
+    }
+  }
+
+  -- Mirror Inductive.lean:2009-2037 compute_k_target (the kernel port).
+  -- K-target valid iff: solo block, result level == 0 (Prop), single
+  -- ctor with 0 fields. Returns 1 if K-target, else 0.
+  -- the kernel solo detection: parent inductive's block_addr == parent's own
+  -- addr (Muts wrappers set block_addr = wrapper addr, standalone sets
+  -- it to self). Additionally load Muts if present and check
+  -- member-count == 1 for singleton-Muts case.
+  fn compute_k_target(ind_ci: KConstantInfo, ind_addr: Addr) -> G {
+    match ind_ci {
+      KConstantInfo.Induct(_, ind_ty, n_params, n_indices, num_ctors,
+                             _, block_addr, ind_idx) =>
+        let is_solo = ind_is_solo(block_addr, ind_addr);
+        match is_solo {
+          0 => 0,
+          _ =>
+            let result_level = get_result_sort_level(ind_ty,
+              n_params + n_indices, store(ListNode.Nil));
+            match level_equal(result_level, store(KLevelNode.Zero)) {
+              0 => 0,
+              _ =>
+                match num_ctors {
+                  1 =>
+                    let ctor_ci = load(get_ci_cprj(block_addr,
+                      ind_idx, 0));
+                    match ctor_ci {
+                      KConstantInfo.Ctor(_, _, _, _, _, _, n_fields, _) =>
+                        eq_zero(n_fields),
+                      _ => 0,
+                    },
+                  _ => 0,
+                },
+            },
+        },
+      _ => 0,
+    }
+  }
+
+  -- Solo iff (a) standalone (block_addr == self) OR
+  -- (b) Muts wrapper containing exactly one Indc member.
+  fn ind_is_solo(block_addr: Addr, ind_addr: Addr) -> G {
+    match address_eq(block_addr, ind_addr) {
+      1 => 1,
+      _ =>
+        let block_c = load_verified_constant(block_addr);
+        match block_c {
+          Constant.Mk(info, _, _, _) =>
+            match info {
+              ConstantInfo.Muts(members) => muts_indc_count_is_one(members, 0),
+              _ => 0,
+            },
+        },
+    }
+  }
+
+  fn is_muts_block(addr: Addr) -> G {
+    let block_c = load_verified_constant(addr);
+    match block_c {
+      Constant.Mk(info, _, _, _) =>
+        match info {
+          ConstantInfo.Muts(_) => 1,
+          _ => 0,
+        },
+    }
+  }
+
+  fn muts_indc_count_is_one(members: List‹MutConst›, count: G) -> G {
+    match load(members) {
+      ListNode.Nil =>
+        match count {
+          1 => 1,
+          _ => 0,
+        },
+      ListNode.Cons(m, rest) =>
+        match m {
+          MutConst.Indc(_) => muts_indc_count_is_one(rest, count + 1),
+          _ => muts_indc_count_is_one(rest, count),
+        },
+    }
+  }
+
+  -- Shape-level recursor validation: rule count plus k_flag consistency
+  -- (the k_flag stored in the recursor's KCI must equal what
+  -- compute_k_target says about its parent inductive).
+  --
+  -- This is weaker than full canonical-rules identity (build_flat_block +
+  -- build_rec_type + populate_rules + compare_rules, which
+  -- check_recursor_canonical_full does): it does not reconstruct the
+  -- expected rules and compare them, so a rule with the right arity but a
+  -- wrong right-hand side passes here. What it does catch:
+  --   * Parent inductive (via block_addr + rec_idx) exists and is Induct.
+  --   * Rules count matches parent's num_ctors — adversarial rules-count
+  --     mismatch (fake extra ctor rule / missing rule) rejected.
+  -- Canonical rules identity (iota-rhs shape verification) deferred; an
+  -- adversarial recursor with type-checking but semantically-wrong rules
+  -- surfaces at def_eq time when reducing `rec (ctor args)`.
+  -- Extract parent inductive's addr from recursor's type. Mirror
+  -- rec_to_ind_idx_with_ty: peel (params + motives + minors + indices)
+  -- Foralls; next Forall's domain is `major`, a Const-headed spine of
+  -- the parent inductive. Take head's caddr. Works for both standalone
+  -- and Muts-wrapped recursors (the kernel addr-first — one path).
+  fn rec_to_parent_addr(ty: KExpr, n_p: G, n_mot: G, n_min: G,
+                             n_i: G) -> Addr {
+    let skip = n_p + n_mot + n_min + n_i;
+    let after_skip = peel_n_foralls(ty, skip);
+    match load(after_skip) {
+      KExprNode.Forall(major_ty, _) =>
+        match collect_spine(major_ty) {
+          (head, _) =>
+            match load(head) {
+              KExprNode.Const(caddr, _) => caddr,
+            },
+        },
+    }
+  }
+
+  -- Extract aux recursor's spec_params: peel outer Foralls to reach
+  -- major, take spine[0..ext_np) of major's dom. For non-aux, returns
+  -- []; for aux, returns the params the ext parent was applied with
+  -- (e.g., Tree.rec_1 for List Tree: spec_params = [Tree]).
+  -- Universe args of a nested occurrence, read off the head of the aux
+  -- recursor's major premise. These are CONCRETE — the levels the
+  -- occurrence was actually applied with — not the recursor's own shifted
+  -- parameters. An original member's motive quantifies over the block's
+  -- params, but an aux member's occurrence was fixed at the point of
+  -- nesting, so rebuilding it from `univ_offset` names a different universe
+  -- than the declared recursor does.
+  fn extract_aux_occ_us(rec_ci: KConstantInfo) -> List‹KLevel› {
+    match rec_ci {
+      KConstantInfo.Rec(_, ty, np, ni, nmot, nmin, _, _, _, _, _) =>
+        let skip = ((np + nmot) + nmin) + ni;
+        match load(peel_n_foralls(ty, skip)) {
+          KExprNode.Forall(major_ty, _) =>
+            match collect_spine(major_ty) {
+              (head, _) =>
+                match load(head) {
+                  KExprNode.Const(_, us) => us,
+                  _ => store(ListNode.Nil),
+                },
+            },
+          _ => store(ListNode.Nil),
+        },
+      _ => store(ListNode.Nil),
+    }
+  }
+
+  -- 1 iff every level is a bare Param. The flat-block machinery downstream
+  -- assumes that shape; a concrete occurrence may legitimately carry Succ or
+  -- Max levels, and those must not be fed into it.
+  fn lvls_all_params(us: List‹KLevel›) -> G {
+    match load(us) {
+      ListNode.Nil => 1,
+      ListNode.Cons(u, rest) =>
+        match load(u) {
+          KLevelNode.Param(_) => lvls_all_params(rest),
+          _ => 0,
+        },
+    }
+  }
+
+  fn extract_aux_spec_params(ty: KExpr, n_p: G, n_mot: G, n_min: G,
+                                   n_i: G, ext_np: G) -> List‹KExpr› {
+    let skip = n_p + n_mot + n_min + n_i;
+    let after_skip = peel_n_foralls(ty, skip);
+    match load(after_skip) {
+      KExprNode.Forall(major_ty, _) =>
+        match collect_spine(major_ty) {
+          (_head, args) =>
+            -- De-lift to the recursor-param frame (block param j at
+            -- BVar(n_p-1-j)) — the storage convention every consumer
+            -- assumes. The args were read off the major premise, which
+            -- sits n_mot + n_min + n_i binders above the params, so
+            -- storing them raw leaves every consumer to re-derive that
+            -- offset from data it does not have. Lowering here also
+            -- makes the same occurrence found at two different field
+            -- depths intern to the same pointer, which is what the
+            -- spec_params_ptr_eq dedup relies on.
+            spec_params_lower(list_take(args, ext_np),
+              (n_mot + n_min) + n_i),
+        },
+    }
+  }
+
+  -- Lower each spec_param out of the major-premise frame into the
+  -- recursor-param frame. Asserts rather than lowering blindly: a param
+  -- arg that references a motive, minor, or index binder has no image in
+  -- the param frame, and expr_lower would silently capture it.
+  fn spec_params_lower(sps: List‹KExpr›, d: G) -> List‹KExpr› {
+    match load(sps) {
+      ListNode.Nil => store(ListNode.Nil),
+      ListNode.Cons(sp, rest) =>
+        assert_eq!(has_bvar_in_range(sp, 0, d), 0,
+          "nested occurrence's parameter references a motive, minor, or index binder");
+        store(ListNode.Cons(expr_lower(sp, d, 0),
+                            spec_params_lower(rest, d))),
+    }
+  }
+
+  -- ============================================================================
+  -- Flat block construction.
+  --
+  -- A flat block is the list of members the recursor iterates over,
+  -- comprising (a) originals: all Indc members of the rec's own Muts
+  -- block, plus (b) auxes: nested-external inductive occurrences
+  -- discovered by scanning member ctors for external Const-headed spines.
+  --
+  -- Each flat entry:
+  --   (member_addr: Addr, is_aux: G, spec_params: List<KExpr>,
+  --    occurrence_us: List<KLevel>)
+  --
+  -- For originals: member_addr = IPrj wrapper addr in the Muts block,
+  -- is_aux = 0, spec_params = [], occurrence_us = [Param(univ_offset),
+  -- Param(univ_offset+1), ..., Param(univ_offset+ind_nlvls-1)].
+  --
+  -- For auxes: member_addr = the EXT inductive's addr (from the nested
+  -- occurrence), is_aux = 1, spec_params = the concrete substitution for
+  -- ext parent's params (usually block members), occurrence_us = the
+  -- universe args from the nested reference.
+  --
+  -- Standalone (non-Muts) blocks: single-entry with the standalone Ind's
+  -- own addr, occurrence_us built from its stored nlvls.
+  -- ============================================================================
+
+  -- Build param-lvls range: [Param(start), Param(start+1), ..., Param(start+count-1)].
+  fn build_param_lvls_range(start: G, count: G, i: G) -> List‹KLevel› {
+    match count - i {
+      0 => store(ListNode.Nil),
+      _ =>
+        store(ListNode.Cons(
+          store(KLevelNode.Param(start + i)),
+          build_param_lvls_range(start, count, i + 1))),
+    }
+  }
+
+  -- Originals of a flat block: walk Muts Indc members, build entry per Indc.
+  -- For standalone (non-Muts) blocks: single-entry with block_addr itself.
+  fn build_flat_originals(block_addr: Addr, univ_offset: G)
+                                -> List‹(Addr, G, List‹KExpr›, List‹KLevel›)› {
+    let block_c = load_verified_constant(block_addr);
+    match block_c {
+      Constant.Mk(info, _, _, _) =>
+        match info {
+          ConstantInfo.Muts(members) =>
+            flat_originals_walk(members, members, block_addr,
+              univ_offset, 0),
+          _ =>
+            -- Standalone: single entry with self addr; fetch nlvls
+            -- via get_ci on block_addr (which resolves to this Ind).
+            let ci = load(get_ci(block_addr));
+            match ci {
+              KConstantInfo.Induct(nlvls, _, _, _, _, _, _, _) =>
+                let occ = build_param_lvls_range(univ_offset, nlvls, 0);
+                store(ListNode.Cons(
+                  (block_addr, 0, store(ListNode.Nil), occ),
+                  store(ListNode.Nil))),
+              _ => store(ListNode.Nil),
+            },
+        },
+    }
+  }
+
+  fn flat_originals_walk(all_members: List‹MutConst›,
+                              cur: List‹MutConst›, block_addr: Addr,
+                              univ_offset: G, pos: G)
+                              -> List‹(Addr, G, List‹KExpr›, List‹KLevel›)› {
+    match load(cur) {
+      ListNode.Nil => store(ListNode.Nil),
+      ListNode.Cons(m, rest) =>
+        match m {
+          MutConst.Indc(_) =>
+            let member_addr = projection_addr(all_members, block_addr, pos);
+            let member_ci = load(get_ci_iprj(block_addr, pos));
+            let nlvls = match member_ci {
+              KConstantInfo.Induct(nl, _, _, _, _, _, _, _) => nl,
+              _ => 0,
+            };
+            let occ = build_param_lvls_range(univ_offset, nlvls, 0);
+            store(ListNode.Cons(
+              (member_addr, 0, store(ListNode.Nil), occ),
+              flat_originals_walk(all_members, rest, block_addr,
+                univ_offset, pos + 1))),
+          _ =>
+            flat_originals_walk(all_members, rest, block_addr,
+              univ_offset, pos + 1),
+        },
+    }
+  }
+
+  -- Detect aux entries by scanning Recr members of a Muts block. Each
+  -- Recr whose parsed parent Ind is NOT a member of the same block is
+  -- an aux (compiler-generated for nested-ext traversal). Parent's addr
+  -- becomes the aux's target inductive; spec_params come from the aux
+  -- Recr's ty major spine (first ext_np args).
+  fn detect_aux_from_recrs(block_addr: Addr, univ_offset: G,
+                                 originals: List‹(Addr, G, List‹KExpr›, List‹KLevel›)›)
+                                -> List‹(Addr, G, List‹KExpr›, List‹KLevel›)› {
+    let block_c = load_verified_constant(block_addr);
+    match block_c {
+      Constant.Mk(info, _, _, _) =>
+        match info {
+          ConstantInfo.Muts(members) =>
+            aux_from_recrs_walk(members, members, block_addr,
+              univ_offset, originals, 0),
+          _ => store(ListNode.Nil),
+        },
+    }
+  }
+
+  -- Check if aux (parent_addr, spec_params) already present in flat_so_far.
+  fn aux_already_in(flat: List‹(Addr, G, List‹KExpr›, List‹KLevel›)›,
+                          target_addr: Addr,
+                          target_sp: List‹KExpr›) -> G {
+    match load(flat) {
+      ListNode.Nil => 0,
+      ListNode.Cons(m, rest) =>
+        match m {
+          (addr, is_aux, sp, _ou) =>
+            match is_aux {
+              1 =>
+                match address_eq(addr, target_addr) {
+                  1 =>
+                    match spec_params_ptr_eq(sp, target_sp) {
+                      1 => 1,
+                      _ => aux_already_in(rest, target_addr, target_sp),
+                    },
+                  _ => aux_already_in(rest, target_addr, target_sp),
+                },
+              _ => aux_already_in(rest, target_addr, target_sp),
+            },
+        },
+    }
+  }
+
+  -- Structural equality on KExpr. Pointer equality is a fast path with
+  -- this walk as the complete fallback, so a de-interned duplicate costs
+  -- a traversal rather than a wrong answer. Addresses inside `Const` and
+  -- `Proj` compare with `address_eq` for the same reason.
+  --
+  -- Deliberately does NOT whnf: callers compare spine-arg prefixes
+  -- against flat-member spec_params, both produced by the same
+  -- block-flattening pass, so they are directly comparable.
+  fn kexpr_struct_eq(a: KExpr, b: KExpr) -> G {
+    match ptr_val(a) - ptr_val(b) {
+      0 => 1,
+      _ =>
+        match load(a) {
+          KExprNode.BVar(ia) =>
+            match load(b) {
+              KExprNode.BVar(ib) =>
+                match ia - ib { 0 => 1, _ => 0, },
+              _ => 0,
+            },
+          KExprNode.Srt(la) =>
+            match load(b) {
+              KExprNode.Srt(lb) => level_struct_eq(la, lb),
+              _ => 0,
+            },
+          KExprNode.Const(ca, lsa) =>
+            match load(b) {
+              KExprNode.Const(cb, lsb) =>
+                match address_eq(ca, cb) {
+                  1 => level_list_struct_eq(lsa, lsb),
+                  _ => 0,
+                },
+              _ => 0,
+            },
+          KExprNode.App(fa, aa) =>
+            match load(b) {
+              KExprNode.App(fb, ab) =>
+                match kexpr_struct_eq(fa, fb) {
+                  1 => kexpr_struct_eq(aa, ab),
+                  _ => 0,
+                },
+              _ => 0,
+            },
+          KExprNode.Lam(ta, ba) =>
+            match load(b) {
+              KExprNode.Lam(tb, bb) =>
+                match kexpr_struct_eq(ta, tb) {
+                  1 => kexpr_struct_eq(ba, bb),
+                  _ => 0,
+                },
+              _ => 0,
+            },
+          KExprNode.Forall(da, xa) =>
+            match load(b) {
+              KExprNode.Forall(db, xb) =>
+                match kexpr_struct_eq(da, db) {
+                  1 => kexpr_struct_eq(xa, xb),
+                  _ => 0,
+                },
+              _ => 0,
+            },
+          KExprNode.Let(ta, va, ba) =>
+            match load(b) {
+              KExprNode.Let(tb, vb, bb) =>
+                match kexpr_struct_eq(ta, tb) {
+                  1 =>
+                    match kexpr_struct_eq(va, vb) {
+                      1 => kexpr_struct_eq(ba, bb),
+                      _ => 0,
+                    },
+                  _ => 0,
+                },
+              _ => 0,
+            },
+          KExprNode.Lit(la) =>
+            match load(b) {
+              KExprNode.Lit(lb) => literal_eq(la, lb),
+              _ => 0,
+            },
+          KExprNode.Proj(sa, fa2, ea) =>
+            match load(b) {
+              KExprNode.Proj(sb, fb2, eb) =>
+                match address_eq(sa, sb) {
+                  1 =>
+                    match fa2 - fb2 {
+                      0 => kexpr_struct_eq(ea, eb),
+                      _ => 0,
+                    },
+                  _ => 0,
+                },
+              _ => 0,
+            },
+        },
+    }
+  }
+
+  fn level_list_struct_eq(a: List‹KLevel›, b: List‹KLevel›) -> G {
+    match load(a) {
+      ListNode.Nil =>
+        match load(b) {
+          ListNode.Nil => 1,
+          _ => 0,
+        },
+      ListNode.Cons(x, xr) =>
+        match load(b) {
+          ListNode.Nil => 0,
+          ListNode.Cons(y, yr) =>
+            match level_struct_eq(x, y) {
+              1 => level_list_struct_eq(xr, yr),
+              _ => 0,
+            },
+        },
+    }
+  }
+
+  -- FAIL-OPEN consumer (`flat_find_pos_kind`): a wrong "not equal" makes
+  -- a flat position fail to match, changing the reconstruction. Structural
+  -- compare, not raw pointer equality.
+  fn spec_params_ptr_eq(a: List‹KExpr›, b: List‹KExpr›) -> G {
+    match load(a) {
+      ListNode.Nil =>
+        match load(b) {
+          ListNode.Nil => 1,
+          _ => 0,
+        },
+      ListNode.Cons(x, xr) =>
+        match load(b) {
+          ListNode.Nil => 0,
+          ListNode.Cons(y, yr) =>
+            match kexpr_struct_eq(x, y) {
+              1 => spec_params_ptr_eq(xr, yr),
+              _ => 0,
+            },
+        },
+    }
+  }
+
+  fn aux_from_recrs_walk(all_members: List‹MutConst›,
+                              cur: List‹MutConst›, block_addr: Addr,
+                              univ_offset: G,
+                              acc: List‹(Addr, G, List‹KExpr›, List‹KLevel›)›,
+                              pos: G)
+                              -> List‹(Addr, G, List‹KExpr›, List‹KLevel›)› {
+    match load(cur) {
+      ListNode.Nil => acc,
+      ListNode.Cons(m, rest) =>
+        match m {
+          MutConst.Recr(_) =>
+            let rec_wrapper = projection_addr(all_members, block_addr, pos);
+            let rec_ci = load(get_ci(rec_wrapper));
+            let entry_opt = match rec_ci {
+              KConstantInfo.Rec(_, ty, np, ni, nmot, nmin, _, _, _, _, _) =>
+                let parent_addr = rec_to_parent_addr(ty, np, nmot, nmin, ni);
+                let parent_ci = load(get_ci(parent_addr));
+                match parent_ci {
+                  KConstantInfo.Induct(pnlvls, _, pnp, _, _, _, pblock, _) =>
+                    match address_eq(pblock, block_addr) {
+                      1 => (0, parent_addr, 0, pnp, pnlvls),
+                      _ => (1, parent_addr, 1, pnp, pnlvls),
+                    },
+                  _ => (0, parent_addr, 0, 0, 0),
+                },
+              _ => (0, block_addr, 0, 0, 0),
+            };
+            match entry_opt {
+              (0, _, _, _, _) =>
+                aux_from_recrs_walk(all_members, rest, block_addr,
+                  univ_offset, acc, pos + 1),
+              (_, parent_addr, _, pnp, pnlvls) =>
+                let spec_params = extract_aux_spec_params_from_rec(
+                  rec_ci, pnp);
+                let occ = build_param_lvls_range(univ_offset, pnlvls, 0);
+                match aux_already_in(acc, parent_addr, spec_params) {
+                  1 =>
+                    aux_from_recrs_walk(all_members, rest, block_addr,
+                      univ_offset, acc, pos + 1),
+                  _ =>
+                    let new_acc = list_snoc(acc,
+                      (parent_addr, 1, spec_params, occ));
+                    aux_from_recrs_walk(all_members, rest, block_addr,
+                      univ_offset, new_acc, pos + 1),
+                },
+            },
+          _ =>
+            aux_from_recrs_walk(all_members, rest, block_addr,
+              univ_offset, acc, pos + 1),
+        },
+    }
+  }
+
+  fn extract_aux_spec_params_from_rec(rec_ci: KConstantInfo,
+                                           ext_np: G) -> List‹KExpr› {
+    match rec_ci {
+      KConstantInfo.Rec(_, ty, np, ni, nmot, nmin, _, _, _, _, _) =>
+        extract_aux_spec_params(ty, np, nmot, nmin, ni, ext_np),
+      _ => store(ListNode.Nil),
+    }
+  }
+
+  -- Combine originals + auxes into full flat block.
+  -- Originals come from PARENT inductive block (Muts of Indc members, or
+  -- standalone Ind); auxes come from recursor block's Recr members whose
+  -- parent inductive is NOT in that primary parent block.
+  -- Standalone recursor (rec_block not Muts): return empty flat — canonical
+  -- runs only when rec_block is Muts (mutual/aux recursor). Handles solo
+  -- recursors with nested-forall recursive fields whose IH construction
+  -- would require deeper machinery than currently ported.
+  -- The block whose inductives OWN this recursor block, i.e. the one whose
+  -- ctors Lean numbers first when laying out minor premises.
+  --
+  -- It is neither `rec_block_addr` (which in the common layout holds only
+  -- `Recr` members) nor `parent_block_addr` (which for an AUX recursor is
+  -- the external nested inductive's block). Derive it instead: take the
+  -- FIRST `Recr` member of the recursor block and follow it to its
+  -- parent's block. For `Tree`'s recursor block that member is `Tree.rec`,
+  -- giving `Tree`'s block, which keeps the aux over `List Tree` off flat
+  -- position 0 — position 0 must be the primary original. For a mutual
+  -- block like `Even`/`Odd` the first recursor's parent is already in the
+  -- inductive block, so this agrees with `parent_block_addr` there.
+  fn primary_parent_block_of(rec_block_addr: Addr, fallback: Addr) -> Addr {
+    let block_c = load_verified_constant(rec_block_addr);
+    match block_c {
+      Constant.Mk(info, _, _, _) =>
+        match info {
+          ConstantInfo.Muts(members) =>
+            first_recr_parent_block(members, members, rec_block_addr, 0,
+              fallback),
+          _ => fallback,
+        },
+    }
+  }
+
+  fn first_recr_parent_block(all_members: List‹MutConst›,
+                                  cur: List‹MutConst›, block_addr: Addr,
+                                  pos: G, fallback: Addr) -> Addr {
+    match load(cur) {
+      ListNode.Nil => fallback,
+      ListNode.Cons(m, rest) =>
+        match m {
+          MutConst.Recr(_) =>
+            let wrapper = projection_addr(all_members, block_addr, pos);
+            let rec_ci = load(get_ci(wrapper));
+            match rec_ci {
+              KConstantInfo.Rec(_, ty, np, ni, nmot, nmin, _, _, _, _, _) =>
+                let parent = rec_to_parent_addr(ty, np, nmot, nmin, ni);
+                let parent_ci = load(get_ci(parent));
+                match parent_ci {
+                  KConstantInfo.Induct(_, _, _, _, _, _, pb, _) => pb,
+                  _ => fallback,
+                },
+              _ => fallback,
+            },
+          _ => first_recr_parent_block(all_members, rest, block_addr,
+                 pos + 1, fallback),
+        },
+    }
+  }
+
+  fn build_flat_block(rec_block_addr: Addr, parent_block_addr: Addr,
+                             univ_offset: G)
+                            -> List‹(Addr, G, List‹KExpr›, List‹KLevel›)› {
+    -- `build_flat_originals` already handles a standalone parent (single
+    -- entry keyed by its own addr). The only thing a non-Muts recursor
+    -- block lacks is Recr MEMBERS to scan for nested-aux entries, so skip
+    -- that pass — never return an empty flat block. An empty one makes
+    -- `flat_find_pos_kind` fail for every solo inductive, which silently
+    -- skips the entire canonical rules comparison.
+    --
+    -- Originals come from the OWNING inductive block (see
+    -- `primary_parent_block_of`), not from `parent_block_addr`: for an aux
+    -- recursor the parent is the external nested inductive, and seeding
+    -- originals from it would put that member at flat position 0. Position
+    -- 0 must be the primary, because `ctors_before_pos` derives minor
+    -- offsets from flat order and Lean numbers the owning block's ctors
+    -- first — get this wrong and the reconstructed rhs references the wrong
+    -- minor premise.
+    let primary_block = primary_parent_block_of(rec_block_addr,
+      parent_block_addr);
+    let originals = build_flat_originals(primary_block, univ_offset);
+    match is_muts_block(rec_block_addr) {
+      0 => originals,
+      _ =>
+        detect_aux_from_recrs_ex(rec_block_addr, primary_block,
+                                       univ_offset, originals),
+    }
+  }
+
+  -- Aux detection variant: parent's block must match parent_block_addr
+  -- to be an original (filtered out); otherwise it becomes an aux.
+  fn detect_aux_from_recrs_ex(rec_block_addr: Addr,
+                                    parent_block_addr: Addr,
+                                    univ_offset: G,
+                                    originals: List‹(Addr, G, List‹KExpr›, List‹KLevel›)›)
+                                   -> List‹(Addr, G, List‹KExpr›, List‹KLevel›)› {
+    let block_c = load_verified_constant(rec_block_addr);
+    match block_c {
+      Constant.Mk(info, _, _, _) =>
+        match info {
+          ConstantInfo.Muts(members) =>
+            aux_from_recrs_walk_ex(members, members, rec_block_addr,
+                                        parent_block_addr, univ_offset,
+                                        originals, 0),
+          _ => originals,
+        },
+    }
+  }
+
+  fn aux_from_recrs_walk_ex(all_members: List‹MutConst›,
+                                  cur: List‹MutConst›,
+                                  rec_block_addr: Addr,
+                                  primary_parent_block: Addr,
+                                  univ_offset: G,
+                                  acc: List‹(Addr, G, List‹KExpr›, List‹KLevel›)›,
+                                  pos: G)
+                                 -> List‹(Addr, G, List‹KExpr›, List‹KLevel›)› {
+    match load(cur) {
+      ListNode.Nil => acc,
+      ListNode.Cons(m, rest) =>
+        match m {
+          MutConst.Recr(_) =>
+            let rec_wrapper = projection_addr(all_members, rec_block_addr, pos);
+            let rec_ci = load(get_ci(rec_wrapper));
+            let entry_opt = match rec_ci {
+              KConstantInfo.Rec(_, ty, np, ni, nmot, nmin, _, _, _, _, _) =>
+                let parent_addr = rec_to_parent_addr(ty, np, nmot, nmin, ni);
+                let parent_ci = load(get_ci(parent_addr));
+                match parent_ci {
+                  KConstantInfo.Induct(pnlvls, _, pnp, _, _, _, pblock, _) =>
+                    match address_eq(pblock, primary_parent_block) {
+                      1 => (0, parent_addr, 0, pnp, pnlvls),
+                      _ => (1, parent_addr, 1, pnp, pnlvls),
+                    },
+                  _ => (0, parent_addr, 0, 0, 0),
+                },
+              _ => (0, primary_parent_block, 0, 0, 0),
+            };
+            match entry_opt {
+              (0, _, _, _, _) =>
+                aux_from_recrs_walk_ex(all_members, rest, rec_block_addr,
+                  primary_parent_block, univ_offset, acc, pos + 1),
+              (_, parent_addr, _, pnp, pnlvls) =>
+                let spec_params = extract_aux_spec_params_from_rec(
+                  rec_ci, pnp);
+                let occ = extract_aux_occ_us(rec_ci);
+                match aux_already_in(acc, parent_addr, spec_params) {
+                  1 =>
+                    aux_from_recrs_walk_ex(all_members, rest, rec_block_addr,
+                      primary_parent_block, univ_offset, acc, pos + 1),
+                  _ =>
+                    let new_acc = list_snoc(acc,
+                      (parent_addr, 1, spec_params, occ));
+                    aux_from_recrs_walk_ex(all_members, rest, rec_block_addr,
+                      primary_parent_block, univ_offset, new_acc, pos + 1),
+                },
+            },
+          _ =>
+            aux_from_recrs_walk_ex(all_members, rest, rec_block_addr,
+              primary_parent_block, univ_offset, acc, pos + 1),
+        },
+    }
+  }
+
+  -- Look up flat member position by target inductive addr. Returns
+  -- (found=0/1, pos). For non-aux target: matches original's member_addr.
+  -- For aux target: matches aux's target ext addr.
+  fn flat_find_pos(flat: List‹(Addr, G, List‹KExpr›, List‹KLevel›)›,
+                        target_addr: Addr, pos: G) -> (G, G) {
+    match load(flat) {
+      ListNode.Nil => (0, 0),
+      ListNode.Cons(m, rest) =>
+        match m {
+          (member_addr, _is_aux, _sp, _ou) =>
+            match address_eq(member_addr, target_addr) {
+              1 => (1, pos),
+              _ => flat_find_pos(rest, target_addr, pos + 1),
+            },
+        },
+    }
+  }
+
+  -- Aux-aware lookup: prefer aux entry with matching (addr, spec_params)
+  -- if want_aux=1, else prefer original (is_aux=0) match by addr.
+  fn flat_find_pos_kind(flat: List‹(Addr, G, List‹KExpr›, List‹KLevel›)›,
+                             target_addr: Addr,
+                             want_aux: G,
+                             want_sp: List‹KExpr›,
+                             pos: G) -> (G, G) {
+    match load(flat) {
+      ListNode.Nil => (0, 0),
+      ListNode.Cons(m, rest) =>
+        match m {
+          (member_addr, is_aux, sp, _ou) =>
+            let addr_match = address_eq(member_addr, target_addr);
+            let kind_eq = match want_aux - is_aux {
+              0 => 1,
+              _ => 0,
+            };
+            let sp_eq = match want_aux {
+              1 => spec_params_ptr_eq(sp, want_sp),
+              _ => 1,
+            };
+            match (addr_match * kind_eq) * sp_eq {
+              1 => (1, pos),
+              _ => flat_find_pos_kind(rest, target_addr, want_aux,
+                                           want_sp, pos + 1),
+            },
+        },
+    }
+  }
+
+  -- Get member at position (returns (addr, is_aux, spec_params, occ_us)).
+  fn flat_member_at(flat: List‹(Addr, G, List‹KExpr›, List‹KLevel›)›,
+                         pos: G) -> (Addr, G, List‹KExpr›, List‹KLevel›) {
+    match load(flat) {
+      ListNode.Nil => (store([0u8; 32]), 0, store(ListNode.Nil),
+                       store(ListNode.Nil)),
+      ListNode.Cons(m, rest) =>
+        match pos {
+          0 => m,
+          _ => flat_member_at(rest, pos - 1),
+        },
+    }
+  }
+
+  -- ============================================================================
+  -- Motive type construction.
+  -- Motive: `∀ (indices) (major : Ind occ_us subst_params indices), Sort elim`.
+  -- For non-aux: subst_params = recursor's param BVars.
+  -- For aux: subst_params = spec_params (lifted).
+  -- ============================================================================
+
+  fn subst_param_for(j: G, n_rec_params: G, is_aux: G,
+                          spec_params: List‹KExpr›) -> KExpr {
+    match is_aux {
+      0 => store(KExprNode.BVar((n_rec_params - 1) - j)),
+      _ =>
+        let len = list_length(spec_params);
+        match u32_less_than(j, len) {
+          1 => list_lookup(spec_params, j),
+          _ => store(KExprNode.BVar((n_rec_params - 1) - j)),
+        },
+    }
+  }
+
+  -- Peel n Foralls; for each binder j substitute per is_aux:
+  -- non-aux: BVar(n_rec_params - 1 - j).
+  -- aux: spec_params[j] when j < |spec_params|, else BVar(n_rec_params - 1 - j).
+  fn peel_motive_params_subst(ty: KExpr, n: G, n_rec_params: G,
+                                    is_aux: G, spec_params: List‹KExpr›,
+                                    j: G) -> KExpr {
+    match n {
+      0 => ty,
+      _ =>
+        match load(ty) {
+          KExprNode.Forall(_, body) =>
+            let p = subst_param_for(j, n_rec_params, is_aux, spec_params);
+            let body_substed = expr_inst1(body, p, 0);
+            peel_motive_params_subst(body_substed, n - 1, n_rec_params,
+              is_aux, spec_params, j + 1),
+        },
+    }
+  }
+
+  -- Mirror crates/kernel/src/inductive.rs — whnf before each peel.
+  -- Index binders can hide under definitional wrappers (e.g. a result type
+  -- `Set σ` only exposes its `σ → Prop` index binder after whnf).
+  fn collect_index_doms(ty: KExpr, n: G) -> List‹KExpr› {
+    match n {
+      0 => store(ListNode.Nil),
+      _ =>
+        match load(ty) {
+          KExprNode.Forall(dom, body) =>
+            store(ListNode.Cons(dom, collect_index_doms(body, n - 1))),
+        },
+    }
+  }
+
+  -- Apply recursor param BVars: head applied to BVar(n_rec_params-1+depth),
+  -- BVar(n_rec_params-2+depth), ..., BVar(depth) (in that order —
+  -- outermost recursor-param first).
+  fn build_major_params(head: KExpr, n_rec_params: G, depth: G,
+                             i: G) -> KExpr {
+    match n_rec_params - i {
+      0 => head,
+      _ =>
+        let v = store(KExprNode.BVar(((n_rec_params - 1) - i) + depth));
+        build_major_params(store(KExprNode.App(head, v)),
+          n_rec_params, depth, i + 1),
+    }
+  }
+
+  fn apply_spec_params_lifted(head: KExpr, spec_params: List‹KExpr›,
+                                    depth: G) -> KExpr {
+    match load(spec_params) {
+      ListNode.Nil => head,
+      ListNode.Cons(sp, rest) =>
+        let lifted = expr_lift(sp, depth, 0);
+        apply_spec_params_lifted(store(KExprNode.App(head, lifted)),
+          rest, depth),
+    }
+  }
+
+  -- For aux: apply spec_params (each lifted by depth=n_indices) to head.
+  -- For non-aux: apply n_rec_params recursor-param BVars to head.
+  fn build_major_args_for_member(head: KExpr, n_rec_params: G,
+                                       depth: G, is_aux: G,
+                                       spec_params: List‹KExpr›) -> KExpr {
+    match is_aux {
+      0 => build_major_params(head, n_rec_params, depth, 0),
+      _ => apply_spec_params_lifted(head, spec_params, depth),
+    }
+  }
+
+  -- Apply index BVars: head applied to BVar(n_indices-1-i) for
+  -- i in 0..n_indices (outermost index first).
+  fn build_major_indices(head: KExpr, n_indices: G, i: G) -> KExpr {
+    match n_indices - i {
+      0 => head,
+      _ =>
+        let v = store(KExprNode.BVar((n_indices - 1) - i));
+        build_major_indices(store(KExprNode.App(head, v)),
+          n_indices, i + 1),
+    }
+  }
+
+  -- Wrap body in foralls outside-in: doms = [d0, d1, ..., dM] →
+  -- `forall (_ : d0), forall (_ : d1), ..., forall (_ : dM), body`.
+  fn wrap_foralls(body: KExpr, doms: List‹KExpr›) -> KExpr {
+    match load(doms) {
+      ListNode.Nil => body,
+      ListNode.Cons(dom, rest) =>
+        store(KExprNode.Forall(dom, wrap_foralls(body, rest))),
+    }
+  }
+
+  -- Collect the first `n` Forall domains, reducing at every step so a
+  -- binder hidden behind a definitional wrapper is still found. Intolerant:
+  -- running out of Foralls means the declared arity disagrees with the
+  -- inductive's, which must reject rather than silently produce a shorter
+  -- telescope for the reconstruction to be compared against.
+  fn collect_n_doms_whnf(ty: KExpr, n: G) -> (List‹KExpr›, KExpr) {
+    match n {
+      0 => (store(ListNode.Nil), ty),
+      _ =>
+        -- Structural first, reduce only if that fails. These bodies carry
+        -- loose BVars (the walk substitutes nothing and the context is
+        -- empty), and reducing such a term unconditionally can destroy a
+        -- Forall that was already in plain sight — which silently shortens
+        -- the telescope the reconstruction is built from.
+        match load(ty) {
+          KExprNode.Forall(dom, body) =>
+            match collect_n_doms_whnf(body, n - 1) {
+              (rest, after) => (store(ListNode.Cons(dom, rest)), after),
+            },
+          _ =>
+            match load(whnf(ty, store(ListNode.Nil))) {
+              KExprNode.Forall(dom, body) =>
+                match collect_n_doms_whnf(body, n - 1) {
+                  (rest, after) => (store(ListNode.Cons(dom, rest)), after),
+                },
+              -- Tolerant, matching both reference kernels: stop early rather
+              -- than reject here. A short telescope yields a reconstruction
+              -- that differs from the declared type, so the def-eq assert
+              -- still rejects — with an accurate message instead of this one.
+              _ => (store(ListNode.Nil), ty),
+            },
+        },
+    }
+  }
+
+  -- Index domains sit inside the motive and minor binders in the recursor
+  -- telescope, so each must be lifted past them. Position `i` is already
+  -- under the `i` index binders that precede it, hence the `i` cutoff.
+  fn list_lift_indices(doms: List‹KExpr›, shift: G, i: G) -> List‹KExpr› {
+    match load(doms) {
+      ListNode.Nil => store(ListNode.Nil),
+      ListNode.Cons(d, rest) =>
+        store(ListNode.Cons(expr_lift(d, shift, i),
+                            list_lift_indices(rest, shift, i + 1))),
+    }
+  }
+
+  -- Apply the recursor's own parameters to the major premise's head. For an
+  -- aux member the parameters are the stored spec_params (lifted from the
+  -- recursor-param frame to this depth) rather than the param BVars.
+  fn build_major_args_for_self(head: KExpr, n_rec_params: G,
+                                     top_bvar: G, spec_lift: G,
+                                     is_aux: G,
+                                     spec_params: List‹KExpr›) -> KExpr {
+    match is_aux {
+      1 => apply_spec_params_lifted(head, spec_params, spec_lift),
+      _ => build_apply_bvars_decreasing(head, n_rec_params, top_bvar, 0),
+    }
+  }
+
+  -- The conclusion applies the motive to the index binders, then to the
+  -- major premise: `motive i_0 ... i_{n-1} major`. Index binder `j` sits at
+  -- BVar(n_indices - j) once the major binder is in scope.
+  fn apply_indices_in_conclusion(head: KExpr, n_indices: G, i: G) -> KExpr {
+    match n_indices - i {
+      0 => head,
+      _ =>
+        let v = store(KExprNode.BVar(n_indices - i));
+        apply_indices_in_conclusion(store(KExprNode.App(head, v)),
+          n_indices, i + 1),
+    }
+  }
+
+  -- Full motive type sig for one flat member.
+  fn build_motive_type_flat(member_addr: Addr, ind_ty: KExpr,
+                                  n_own_params: G, n_indices: G,
+                                  occurrence_us: List‹KLevel›,
+                                  elim_level: KLevel,
+                                  n_rec_params: G,
+                                  is_aux: G,
+                                  spec_params: List‹KExpr›) -> KExpr {
+    let ind_ty_inst = expr_inst_levels(ind_ty, occurrence_us);
+    let after_params = peel_motive_params_subst(ind_ty_inst, n_own_params,
+      n_rec_params, is_aux, spec_params, 0);
+    let index_doms = collect_index_doms(after_params, n_indices);
+    let head = store(KExprNode.Const(member_addr, occurrence_us));
+    let with_args = build_major_args_for_member(head, n_rec_params,
+      n_indices, is_aux, spec_params);
+    let major_ty = build_major_indices(with_args, n_indices, 0);
+    let sort_e = store(KExprNode.Srt(elim_level));
+    let with_major = store(KExprNode.Forall(major_ty, sort_e));
+    wrap_foralls(with_major, index_doms)
+  }
+
+  -- Build all motive types for a flat block. Each member's motive is
+  -- lifted by its position j in the flat list (later motives are under
+  -- more binders in the recursor's outer Lam sequence).
+  fn build_all_motives(flat: List‹(Addr, G, List‹KExpr›, List‹KLevel›)›,
+                            elim_level: KLevel, n_rec_params: G)
+                            -> List‹KExpr› {
+    build_all_motives_walk(flat, elim_level, n_rec_params, 0)
+  }
+
+  -- Apply head to motive BVars starting at `start` descending.
+  fn build_motive_apps(head: KExpr, n_motives: G, start: G,
+                             i: G) -> KExpr {
+    match n_motives - i {
+      0 => head,
+      _ =>
+        let v = store(KExprNode.BVar(start - i));
+        build_motive_apps(store(KExprNode.App(head, v)), n_motives,
+          start, i + 1),
+    }
+  }
+
+  fn build_minor_apps(head: KExpr, n_minors: G, start: G,
+                            i: G) -> KExpr {
+    match n_minors - i {
+      0 => head,
+      _ =>
+        let v = store(KExprNode.BVar(start - i));
+        build_minor_apps(store(KExprNode.App(head, v)), n_minors,
+          start, i + 1),
+    }
+  }
+
+  -- Wrap body in Lams outside-in: doms = [d0, d1, ..., dM] →
+  -- `Lam d0. Lam d1. ... Lam dM. body`.
+  fn wrap_lams(body: KExpr, doms: List‹KExpr›) -> KExpr {
+    match load(doms) {
+      ListNode.Nil => body,
+      ListNode.Cons(dom, rest) =>
+        store(KExprNode.Lam(dom, wrap_lams(body, rest))),
+    }
+  }
+
+  -- Full canonical rules identity check (aux port final assembly).
+  -- Uses complete reference-parallel pipeline: build_flat_block →
+  -- build_peer_recs → build_flat_own_params → populate_rules →
+  -- compare_rules. Handles solo, mutual, and aux recursors.
+  --
+  -- This is the check that makes a recursor's rules trustworthy: without
+  -- it, neither a recursor's type nor its rules are validated against a
+  -- reconstruction, and `is_aux` alone decides how much checking happens.
+  -- Called from check_recursor_member for every recursor.
+  -- Reconstruct a recursor's canonical type from the inductive it
+  -- eliminates:
+  --
+  --   forall (params) (motives) (minors) (indices) (major), motive_self indices major
+  --
+  -- The declared type is adversary-supplied in full — every numeric field
+  -- and the type itself come from the Ixon record — so without comparing
+  -- against this reconstruction a recursor may claim any conclusion at all,
+  -- `False` included, while its rules still reconstruct correctly.
+  fn build_rec_type(ind_ty: KExpr, ind_nlvls: G, n_params: G, n_indices: G,
+                          elim_level: KLevel, univ_offset: G,
+                          flat: List‹(Addr, G, List‹KExpr›, List‹KLevel›)›,
+                          flat_own_params: List‹G›, self_pos: G) -> KExpr {
+    -- Walk the params over the PRIMARY inductive (flat position 0), not the
+    -- recursor's parent. For an aux recursor the parent is the external
+    -- inductive being nested into (e.g. `Array`, one param) while n_params
+    -- is the block's own param count, so peeling the parent's type runs off
+    -- the end and yields a short, malformed telescope.
+    match flat_member_at(flat, 0) {
+      (prim_addr, _pia, _pisp, _piou) =>
+        match load(get_ci(prim_addr)) {
+          KConstantInfo.Induct(prim_nlvls, prim_ty, _, _, _, _, _, _) =>
+            build_rec_type_from(prim_ty, prim_nlvls, ind_ty, ind_nlvls,
+              n_params, n_indices, elim_level, univ_offset, flat,
+              flat_own_params, self_pos),
+          _ =>
+            build_rec_type_from(ind_ty, ind_nlvls, ind_ty, ind_nlvls,
+              n_params, n_indices, elim_level, univ_offset, flat,
+              flat_own_params, self_pos),
+        },
+    }
+  }
+
+  fn build_rec_type_from(prim_ty: KExpr, prim_nlvls: G,
+                               ind_ty: KExpr, ind_nlvls: G,
+                               n_params: G, n_indices: G,
+                               elim_level: KLevel, univ_offset: G,
+                               flat: List‹(Addr, G, List‹KExpr›, List‹KLevel›)›,
+                               flat_own_params: List‹G›, self_pos: G) -> KExpr {
+    let n_motives = list_length(flat);
+    let motive_base = n_params;
+    -- The params telescope is read under the same universe shift the flat
+    -- block was built with, so the reconstructed binders carry the levels
+    -- the declared type must.
+    let p_us = build_param_lvls_range(univ_offset, prim_nlvls, 0);
+    match collect_n_doms_whnf(expr_inst_levels(prim_ty, p_us), n_params) {
+      (param_doms, after_params) =>
+        let motive_doms = build_all_motives(flat, elim_level, n_params);
+        let minor_doms = build_all_minors(flat, flat_own_params, n_params,
+          n_motives, motive_base);
+        let n_minors = list_length(minor_doms);
+        let index_doms_raw = collect_index_doms(after_params, n_indices);
+        let index_doms = list_lift_indices(index_doms_raw,
+          n_motives + n_minors, 0);
+        match flat_member_at(flat, self_pos) {
+          (self_addr, self_is_aux, self_spec_params, self_occ_us) =>
+            let head = store(KExprNode.Const(self_addr, self_occ_us));
+            let pre_major_depth = ((n_params + n_motives) + n_minors) + n_indices;
+            let with_args = build_major_args_for_self(head, n_params,
+              pre_major_depth - 1, (n_motives + n_minors) + n_indices,
+              self_is_aux, self_spec_params);
+            let major_ty = build_major_indices(with_args, n_indices, 0);
+            -- Conclusion is built with the major binder in scope, hence the
+            -- +1: motive_self applied to the index binders, then the major.
+            let depth_after_major = pre_major_depth + 1;
+            let motive_var = (depth_after_major - 1) - (motive_base + self_pos);
+            let motive_ref = store(KExprNode.BVar(motive_var));
+            let with_indices = apply_indices_in_conclusion(motive_ref,
+              n_indices, 0);
+            let conclusion = store(KExprNode.App(with_indices,
+              store(KExprNode.BVar(0))));
+            let with_major = store(KExprNode.Forall(major_ty, conclusion));
+            let with_idx_foralls = wrap_foralls(with_major, index_doms);
+            let with_minors = wrap_foralls(with_idx_foralls, minor_doms);
+            let with_motives = wrap_foralls(with_minors, motive_doms);
+            wrap_foralls(with_motives, param_doms),
+        },
+    }
+  }
+
+  fn check_recursor_canonical_full(rec_ci: KConstantInfo, addr: Addr,
+                                          parent_ci: KConstantInfo,
+                                          parent_addr: Addr) {
+    match rec_ci {
+      KConstantInfo.Rec(nlvls, ty, n_p, n_i, n_mot, n_min, rules,
+                          _k_flag, _uns, rec_block_addr, _rec_idx) =>
+        match parent_ci {
+          KConstantInfo.Induct(pnlvls, pty, pnp, pni, num_ctors, _,
+                                 parent_block_addr, parent_ind_idx) =>
+            let single_ctor_pair = match num_ctors {
+              1 =>
+                let cci = load(get_ci_cprj(parent_block_addr,
+                  parent_ind_idx, 0));
+                (1, cci),
+              _ =>
+                (0, KConstantInfo.Axiom(0, store(KExprNode.Srt(
+                  store(KLevelNode.Zero))), 0)),
+            };
+            let result_level = get_result_sort_level(pty, pnp + pni,
+              store(ListNode.Nil));
+            let univ_offset = is_large_eliminator(result_level,
+              num_ctors, single_ctor_pair);
+            let elim_level = match univ_offset {
+              1 => store(KLevelNode.Param(0)),
+              _ => store(KLevelNode.Zero),
+            };
+            let rec_lvls_list = build_rec_lvls_list(nlvls, 0);
+            let flat = build_flat_block(rec_block_addr, parent_block_addr,
+                                              univ_offset);
+            let peer_recs = build_peer_recs(flat, rec_block_addr, addr);
+            let flat_own_params = build_flat_own_params(flat);
+            let rec_is_aux = is_muts_block(rec_block_addr) *
+              is_muts_block(parent_block_addr) *
+              (1 - address_eq(rec_block_addr, parent_block_addr));
+            let rec_spec_params = match rec_is_aux {
+              1 => extract_aux_spec_params_from_rec(rec_ci, pnp),
+              _ => store(ListNode.Nil),
+            };
+            -- Locate this recursor's parent in the flat block.
+            --
+            -- The kind-aware lookup disambiguates the case where one
+            -- address appears both as an original and as a nested-aux
+            -- entry with distinct spec_params. It is a REFINEMENT, not a
+            -- gate: on a miss, fall back to an address-only match and let
+            -- the entry supply is_aux/spec_params below, which is what
+            -- `flat_member_at` already reads.
+            --
+            -- Requiring the caller's computed `rec_is_aux` to match was a
+            -- silent skip of the whole canonical rules comparison —
+            -- measured at 132 of the suite's recursor checks, every one
+            -- with `want_aux = 1` against a flat list of `is_aux = 0`
+            -- originals. A recursor living in a different block from its
+            -- inductives is not the same thing as an aux recursor, but
+            -- `rec_is_aux` is computed from exactly that block
+            -- difference. A parent genuinely absent from the flat block
+            -- is a real inconsistency and now fails hard.
+            let kind_hit = flat_find_pos_kind(flat, parent_addr,
+                                                    rec_is_aux,
+                                                    rec_spec_params, 0);
+            match kind_hit {
+              (1, self_pos) =>
+                canonical_rules_at_pos(flat, self_pos, num_ctors,
+                  parent_block_addr, parent_ind_idx, n_p, n_mot, n_min,
+                  rec_lvls_list, peer_recs, flat_own_params, rules,
+                  ty, pty, pnlvls, pni, elim_level, univ_offset),
+              _ =>
+                match flat_find_pos(flat, parent_addr, 0) {
+                  (1, self_pos) =>
+                    canonical_rules_at_pos(flat, self_pos, num_ctors,
+                      parent_block_addr, parent_ind_idx, n_p, n_mot,
+                      n_min, rec_lvls_list, peer_recs, flat_own_params,
+                      rules, ty, pty, pnlvls, pni, elim_level, univ_offset),
+                },
+            },
+          _ => (),
+        },
+    }
+  }
+
+  -- Reconstruct the canonical rules for the flat member at `self_pos`
+  -- and compare them against the recursor's stored rules. Split out of
+  -- `check_recursor_canonical_full` so both the kind-aware lookup and the
+  -- address-only fallback can tail-call it (this compiler rejects a
+  -- non-tail `match` bound by `let`).
+  fn canonical_rules_at_pos(flat: List‹(Addr, G, List‹KExpr›, List‹KLevel›)›,
+                                 self_pos: G, num_ctors: G,
+                                 parent_block_addr: Addr,
+                                 parent_ind_idx: G, n_p: G, n_mot: G,
+                                 n_min: G, rec_lvls_list: List‹KLevel›,
+                                 peer_recs: List‹Addr›,
+                                 flat_own_params: List‹G›,
+                                 rules: List‹KRecRule›,
+                                 ty: KExpr, pty: KExpr, pnlvls: G, pni: G,
+                                 elim_level: KLevel, univ_offset: G) {
+    match flat_member_at(flat, self_pos) {
+      (_, is_aux, spec_params, occ_us) =>
+        -- Validate the DECLARED type against the reconstruction. The rule
+        -- comparison below covers only rule right-hand sides; on its own it
+        -- leaves the motive premises, the minor premises, the index binders
+        -- and the CONCLUSION unconstrained, which is enough for a recursor
+        -- to declare `... -> False` and still reconstruct every rule
+        -- correctly. Both the kind-aware lookup and the address-only
+        -- fallback route through here, so neither can skip this.
+        let canonical_ty = build_rec_type(pty, pnlvls, n_p, pni, elim_level,
+          univ_offset, flat, flat_own_params, self_pos);
+        assert_eq!(k_is_def_eq(ty, canonical_ty, store(ListNode.Nil)), 1,
+          "recursor's declared type is not def-eq to the canonical reconstruction");
+        let self_ctors_offset = ctors_before_pos(flat, self_pos, 0);
+        let canonical = populate_rules(num_ctors, self_ctors_offset,
+          parent_block_addr, parent_ind_idx, n_p, n_mot, n_min, occ_us,
+          rec_lvls_list, flat, peer_recs, flat_own_params, is_aux,
+          spec_params, 0);
+        compare_rules(rules, canonical, n_p, n_mot, n_min,
+          parent_block_addr, parent_ind_idx, num_ctors, 0),
+    }
+  }
+
+  -- Sum of num_ctors for flat members before target_pos.
+  fn ctors_before_pos(flat: List‹(Addr, G, List‹KExpr›, List‹KLevel›)›,
+                            target_pos: G, cur_pos: G) -> G {
+    match cur_pos - target_pos {
+      0 => 0,
+      _ =>
+        match load(flat) {
+          ListNode.Nil => 0,
+          ListNode.Cons(m, rest) =>
+            match m {
+              (addr, _, _, _) =>
+                let ci = load(get_ci(addr));
+                let n = match ci {
+                  KConstantInfo.Induct(_, _, _, _, nc, _, _, _) => nc,
+                  _ => 0,
+                };
+                n + ctors_before_pos(rest, target_pos, cur_pos + 1),
+            },
+        },
+    }
+  }
+
+  -- Populate canonical rhs bodies for one recursor's rules (self's
+  -- ctors only). ctor_minor_index = ctors_before_self + cidx.
+  fn populate_rules(num_ctors: G, self_ctors_offset: G,
+                          block_addr: Addr, ind_idx: G,
+                          n_params: G, n_motives: G, n_minors: G,
+                          occurrence_us: List‹KLevel›,
+                          rec_lvls_list: List‹KLevel›,
+                          flat: List‹(Addr, G, List‹KExpr›, List‹KLevel›)›,
+                          peer_recs: List‹Addr›,
+                          flat_own_params: List‹G›,
+                          is_aux: G, spec_params: List‹KExpr›,
+                          cidx: G) -> List‹KExpr› {
+    match num_ctors - cidx {
+      0 => store(ListNode.Nil),
+      _ =>
+        let ctor_ci = load(get_ci_cprj(block_addr, ind_idx, cidx));
+        match ctor_ci {
+          KConstantInfo.Ctor(_, ctor_ty, _, _, _, np, _, _) =>
+            let ctor_minor_index = self_ctors_offset + cidx;
+            let rhs = build_rule_rhs(ctor_ty, ctor_minor_index,
+              n_params, n_motives, n_minors, np, occurrence_us,
+              rec_lvls_list, flat, peer_recs, flat_own_params,
+              is_aux, spec_params);
+            store(ListNode.Cons(rhs,
+              populate_rules(num_ctors, self_ctors_offset, block_addr,
+                ind_idx, n_params, n_motives, n_minors, occurrence_us,
+                rec_lvls_list, flat, peer_recs, flat_own_params, is_aux,
+                spec_params, cidx + 1))),
+          _ => store(ListNode.Nil),
+        },
+    }
+  }
+
+  -- Compare stored rules against canonical rhs list. Per rule: peel
+  -- (n_p + n_mot + n_min + nf) Lams off stored rhs, def_eq against
+  -- canonical body.
+  fn compare_rules(stored: List‹KRecRule›, canonical: List‹KExpr›,
+                        n_p: G, n_mot: G, n_min: G,
+                        block_addr: Addr, ind_idx: G, num_ctors: G, pos: G) {
+    match load(stored) {
+      ListNode.Nil => (),
+      ListNode.Cons(r, rest) =>
+        match r {
+          KRecRule.Mk(cidx, nf, rhs) =>
+            -- Pin the rule's own labels against the constructor it claims.
+            -- Equivalents of these three live in `check_rec_rules_walk`,
+            -- which nothing calls; the live path had none of them.
+            --
+            -- `cidx` selects the rule at reduction time (`find_rule` in
+            -- try_iota) while `compare_rules` pairs stored against
+            -- canonical POSITIONALLY, so permuted labels would fire one
+            -- constructor's rule for another. It holds today only because
+            -- ingress assigns `cidx` positionally (`Convert.lean`) — this
+            -- makes it an asserted invariant rather than a coincidence.
+            --
+            -- `nf` decides how `try_iota` splits the constructor's
+            -- arguments (`field_start = ctor_fields_len - rfields`), so a
+            -- wrong value hands the minor premise the wrong slice.
+            assert_eq!(cidx, pos,
+              "recursor rule is out of ctor order");
+            assert_eq!(u32_less_than(cidx, num_ctors), 1,
+              "recursor rule names a ctor index out of range");
+            let ctor_ci = load(get_ci_cprj(block_addr, ind_idx, cidx));
+            match ctor_ci {
+              KConstantInfo.Ctor(_, _, _, _, _, _, c_nf, _) =>
+                assert_eq!(nf, c_nf,
+                  "recursor rule field count differs from the ctor's");
+                (),
+            };
+            match load(canonical) {
+              ListNode.Nil => (),
+              ListNode.Cons(cbody, crest) =>
+                let total = ((n_p + n_mot) + n_min) + nf;
+                match peel_n_lams_collect(rhs, total, 0,
+                        store(ListNode.Nil)) {
+                  (stored_body, peeled, _) =>
+                    assert_eq!(peeled, total,
+                      "recursor rule rhs has too few binders to peel");
+                    -- Compare under an EMPTY context, discarding the
+                    -- domains just peeled.
+                    --
+                    -- Those domains come off the STORED rule, so they are
+                    -- prover-authored and unvalidated — nothing compares
+                    -- them against the canonical reconstruction, and
+                    -- reduction never consults them (`try_iota` beta-
+                    -- reduces straight through). Feeding them to
+                    -- `k_is_def_eq` let the prover choose what the two
+                    -- sides INFER to: retype every binder to a Prop and
+                    -- proof irrelevance accepts any body, so a recursor
+                    -- whose computation rules are swapped between
+                    -- constructors passed.
+                    --
+                    -- An honest rule matches the reconstruction
+                    -- structurally, and the structural path never
+                    -- consults the context — it compares `BVar i`
+                    -- against `BVar i` directly. Anything that instead
+                    -- needs to INFER a bound variable's type now runs out
+                    -- of context and aborts, which is the safe direction.
+                    assert_eq!(k_is_def_eq(stored_body, cbody,
+                        store(ListNode.Nil)), 1,
+                      "recursor rule rhs differs from canonical reconstruction");
+                    (),
+                };
+                compare_rules(rest, crest, n_p, n_mot, n_min,
+                  block_addr, ind_idx, num_ctors, pos + 1),
+            },
+        },
+    }
+  }
+
+  -- Full IH construction with peer_recs + flat_own_params + arbitrary
+  -- n_motives / n_minors. Mirror apply_ihs (Inductive.lean:1729+).
+  fn apply_ihs_full(head: KExpr, rec_indices: List‹G›,
+                          rec_member_idxs: List‹G›,
+                          field_doms: List‹KExpr›,
+                          peer_recs: List‹Addr›,
+                          flat_own_params: List‹G›,
+                          n_params: G, n_motives: G, n_minors: G,
+                          n_fields: G, rec_lvls_list: List‹KLevel›,
+                          k: G) -> KExpr {
+    match load(rec_indices) {
+      ListNode.Nil => head,
+      ListNode.Cons(field_idx, rest) =>
+        let mem_idx = list_lookup_or_default(rec_member_idxs, k, 0);
+        let target_rec = list_lookup_or_default(peer_recs, mem_idx,
+          store([0u8; 32]));
+        let target_n_params = list_lookup_or_default(flat_own_params,
+          mem_idx, 0);
+        let body_depth = ((n_params + n_motives) + n_minors) + n_fields;
+        let dom = list_lookup(field_doms, field_idx);
+        let dom_s1 = expr_lift(dom, n_fields - field_idx, 0);
+        let dom_lifted = expr_lift(dom_s1, n_motives + n_minors, n_fields);
+        match peel_leading_foralls(dom_lifted) {
+          (forall_doms, inner_body) =>
+            let n_xs = list_length(forall_doms);
+            let inner_depth = body_depth + n_xs;
+            let rec_const = store(KExprNode.Const(target_rec, rec_lvls_list));
+            let with_params = build_apply_bvars_decreasing(rec_const,
+              n_params, inner_depth - 1, 0);
+            let with_motives = build_motive_apps(with_params, n_motives,
+              (inner_depth - 1) - n_params, 0);
+            let with_minors = build_minor_apps(with_motives, n_minors,
+              ((inner_depth - 1) - n_params) - n_motives, 0);
+            -- Reduce before reading the spine. `is_rec_field` whnf's to
+            -- CLASSIFY the field, so a domain like `constType (T a) (T a)`
+            -- is correctly seen as recursive — but the index arguments of
+            -- the induction hypothesis have to come from the REDUCED head
+            -- too. Taking them from the unreduced domain yields the
+            -- wrapper's arguments (`drop 1 [A, B] = [B]`) instead of the
+            -- inductive's (`drop 1 [a] = []`), so the IH was applied to one
+            -- argument too many.
+            match collect_spine(whnf(inner_body, store(ListNode.Nil))) {
+              (_dh, dargs) =>
+                let idx_args = list_drop(dargs, target_n_params);
+                let with_idx = apply_spine_expr(with_minors, idx_args);
+                let field_base = ((n_fields - 1) - field_idx) + n_xs;
+                let field_ref = store(KExprNode.BVar(field_base));
+                let field_app = build_apply_xs(field_ref, n_xs, 0);
+                let ih_inner = store(KExprNode.App(with_idx, field_app));
+                let ih = wrap_lams(ih_inner, forall_doms);
+                let new_head = store(KExprNode.App(head, ih));
+                apply_ihs_full(new_head, rest, rec_member_idxs,
+                  field_doms, peer_recs, flat_own_params, n_params,
+                  n_motives, n_minors, n_fields, rec_lvls_list, k + 1),
+            },
+        },
+    }
+  }
+
+  -- Full canonical rule rhs BODY (all outer Lams peeled). Mirror
+  -- build_rule_rhs (Inductive.lean:1641+). ctor_minor_index = global
+  -- minor position (across all flat members' ctors).
+  fn build_rule_rhs(ctor_ty: KExpr, ctor_minor_index: G,
+                          n_params: G, n_motives: G, n_minors: G,
+                          n_own_params: G,
+                          occurrence_us: List‹KLevel›,
+                          rec_lvls_list: List‹KLevel›,
+                          flat: List‹(Addr, G, List‹KExpr›, List‹KLevel›)›,
+                          peer_recs: List‹Addr›,
+                          flat_own_params: List‹G›,
+                          is_aux: G, spec_params: List‹KExpr›) -> KExpr {
+    let ctor_ty_inst = expr_inst_levels(ctor_ty, occurrence_us);
+    let after_params_raw = peel_n_foralls(ctor_ty_inst, n_own_params);
+    let n_fields = count_foralls_body(after_params_raw, 0);
+    let body_depth = ((n_params + n_motives) + n_minors) + n_fields;
+    -- Peel into the recursor-param frame, not the final body frame:
+    -- apply_ihs_full's two lifts already carry a field domain from the
+    -- param frame to the body frame (together they add exactly
+    -- body_depth - n_params to anything above the field cutoff).
+    -- Substituting body-frame indices here would apply that transport a
+    -- second time, leaving every param reference that survives into a
+    -- binder domain over-shifted.
+    let after_params = peel_ctor_params_subst(ctor_ty_inst, n_own_params,
+      n_own_params, 0, is_aux, spec_params, 0);
+    -- spec_lift_by must name the same frame the spec_params are stored
+    -- in; walk_fields_classify adds the walk depth itself.
+    match walk_fields_classify(after_params, flat, store(ListNode.Nil),
+            store(ListNode.Nil), store(ListNode.Nil), 0, 0) {
+      (field_doms, rec_indices, rec_member_idxs, _ret_ty) =>
+        let minor_var = (body_depth - 1) - ((n_params + n_motives) +
+                                              ctor_minor_index);
+        let base = store(KExprNode.BVar(minor_var));
+        let with_fields = build_apply_field_bvars(base, n_fields,
+          n_fields, 0);
+        apply_ihs_full(with_fields, rec_indices, rec_member_idxs,
+          field_doms, peer_recs, flat_own_params, n_params, n_motives,
+          n_minors, n_fields, rec_lvls_list, 0),
+    }
+  }
+
+  -- Build list of peer recursor addrs (one per flat member).
+  -- For each flat member, find the Recr in rec_block_addr's Muts whose
+  -- parsed parent addr matches AND spec_params match. spec-match
+  -- disambiguates auxes with same target but distinct specs (DedupM).
+  fn build_peer_recs(flat: List‹(Addr, G, List‹KExpr›, List‹KLevel›)›,
+                          rec_block_addr: Addr,
+                          rec_self_addr: Addr) -> List‹Addr› {
+    match load(flat) {
+      ListNode.Nil => store(ListNode.Nil),
+      ListNode.Cons(m, rest) =>
+        match m {
+          (member_addr, is_aux, sp, _ou) =>
+            let peer = find_peer_recursor_with_spec(rec_block_addr,
+              member_addr, sp, is_aux, rec_self_addr);
+            store(ListNode.Cons(peer,
+              build_peer_recs(rest, rec_block_addr, rec_self_addr))),
+        },
+    }
+  }
+
+  fn find_peer_recursor_with_spec(block_addr: Addr,
+                                        target_ind_addr: Addr,
+                                        target_sp: List‹KExpr›,
+                                        target_is_aux: G,
+                                        rec_self_addr: Addr) -> Addr {
+    let block_c = load_verified_constant(block_addr);
+    match block_c {
+      Constant.Mk(info, _, _, _) =>
+        match info {
+          ConstantInfo.Muts(members) =>
+            find_peer_rec_spec_walk(members, members, block_addr,
+              target_ind_addr, target_sp, target_is_aux, rec_self_addr, 0),
+          _ => rec_self_addr,
+        },
+    }
+  }
+
+  fn find_peer_rec_spec_walk(all_members: List‹MutConst›,
+                                   cur: List‹MutConst›, block_addr: Addr,
+                                   target_ind_addr: Addr,
+                                   target_sp: List‹KExpr›,
+                                   target_is_aux: G,
+                                   rec_self_addr: Addr, pos: G) -> Addr {
+    match load(cur) {
+      ListNode.Nil => rec_self_addr,
+      ListNode.Cons(m, rest) =>
+        match m {
+          MutConst.Recr(_) =>
+            let rec_wrapper = projection_addr(all_members, block_addr, pos);
+            let rec_ci = load(get_ci(rec_wrapper));
+            let is_match = match rec_ci {
+              KConstantInfo.Rec(_, ty, np, ni, nmot, nmin, _, _, _, _, _) =>
+                let parent = rec_to_parent_addr(ty, np, nmot, nmin, ni);
+                let parent_ci = load(get_ci(parent));
+                let pnp = match parent_ci {
+                  KConstantInfo.Induct(_, _, p, _, _, _, _, _) => p,
+                  _ => 0,
+                };
+                let addr_m = address_eq(parent, target_ind_addr);
+                match addr_m {
+                  1 =>
+                    match target_is_aux {
+                      0 => 1,
+                      _ =>
+                        let rec_sp = extract_aux_spec_params(ty, np,
+                          nmot, nmin, ni, pnp);
+                        spec_params_ptr_eq(rec_sp, target_sp),
+                    },
+                  _ => 0,
+                },
+              _ => 0,
+            };
+            match is_match {
+              1 => rec_wrapper,
+              _ =>
+                find_peer_rec_spec_walk(all_members, rest, block_addr,
+                  target_ind_addr, target_sp, target_is_aux,
+                  rec_self_addr, pos + 1),
+            },
+          _ =>
+            find_peer_rec_spec_walk(all_members, rest, block_addr,
+              target_ind_addr, target_sp, target_is_aux, rec_self_addr,
+              pos + 1),
+        },
+    }
+  }
+
+  -- Build list of flat member own_params (num_params from each member's
+  -- KCI). Used by build_ih_doms for target_n_params lookup.
+  fn build_flat_own_params(flat: List‹(Addr, G, List‹KExpr›, List‹KLevel›)›)
+                                  -> List‹G› {
+    match load(flat) {
+      ListNode.Nil => store(ListNode.Nil),
+      ListNode.Cons(m, rest) =>
+        match m {
+          (member_addr, _is_aux, _sp, _ou) =>
+            let ci = load(get_ci(member_addr));
+            let np = match ci {
+              KConstantInfo.Induct(_, _, n, _, _, _, _, _) => n,
+              _ => 0,
+            };
+            store(ListNode.Cons(np,
+              build_flat_own_params(rest))),
+        },
+    }
+  }
+
+  -- Synthesize a Ctor's CPrj wrapper addr.
+  -- Bytes = put_constant(Constant{info: CPrj{idx, cidx, block_addr}, ...}).
+  fn projection_addr_ctor(ind_idx: G, cidx: G,
+                                block_addr: Addr) -> Addr {
+    let idx_u64 = idx_to_u64(ind_idx);
+    let cidx_u64 = idx_to_u64(cidx);
+    let info = ConstantInfo.CPrj(ConstructorProj.Mk(idx_u64, cidx_u64,
+      block_addr));
+    let proj_c = Constant.Mk(info,
+      store(ListNode.Nil), store(ListNode.Nil), store(ListNode.Nil));
+    let bytes = put_constant(proj_c, store(ListNode.Nil));
+    bytes_to_addr(bytes)
+  }
+
+  -- Iterate ctors 0..num_ctors-1, build minor for each via
+  -- build_minor_at_depth. Return list of minor doms.
+  fn build_minor_doms(member_addr: Addr, is_aux: G,
+                            spec_params: List‹KExpr›,
+                            occurrence_us: List‹KLevel›,
+                            flat: List‹(Addr, G, List‹KExpr›, List‹KLevel›)›,
+                            flat_own_params: List‹G›,
+                            n_rec_params: G, n_motives: G,
+                            motive_base: G, self_mem_idx: G,
+                            block_addr: Addr, ind_idx: G,
+                            num_ctors: G, prev_minors: G,
+                            cidx: G) -> List‹KExpr› {
+    match num_ctors - cidx {
+      0 => store(ListNode.Nil),
+      _ =>
+        let ctor_ci = load(get_ci_cprj(block_addr, ind_idx, cidx));
+        match ctor_ci {
+          KConstantInfo.Ctor(_, ctor_ty, _, _, _, np, _nf, _) =>
+            let ctor_addr = projection_addr_ctor(ind_idx, cidx, block_addr);
+            let minor = build_minor_at_depth(ctor_addr, ctor_ty, np,
+              is_aux, spec_params, occurrence_us, flat, flat_own_params,
+              n_rec_params, n_motives, prev_minors, motive_base,
+              self_mem_idx);
+            store(ListNode.Cons(minor,
+              build_minor_doms(member_addr, is_aux, spec_params,
+                occurrence_us, flat, flat_own_params, n_rec_params,
+                n_motives, motive_base, self_mem_idx, block_addr, ind_idx,
+                num_ctors, prev_minors + 1, cidx + 1))),
+          -- No tolerant arm on purpose. Returning Nil for a non-Ctor would
+          -- yield a canonical type with FEWER minor premises than the
+          -- inductive has constructors, and the declared type is
+          -- adversary-supplied, so it could be built to match the truncated
+          -- reconstruction. Falling off the match rejects instead.
+        },
+    }
+  }
+
+  -- Iterate flat, per member call build_minor_doms with appropriate
+  -- block_addr/ind_idx (from member_addr's KCI).
+  fn build_all_minors(flat: List‹(Addr, G, List‹KExpr›, List‹KLevel›)›,
+                            flat_own_params: List‹G›,
+                            n_rec_params: G, n_motives: G,
+                            motive_base: G) -> List‹KExpr› {
+    build_all_minors_walk(flat, flat, flat_own_params, n_rec_params,
+      n_motives, motive_base, 0, 0)
+  }
+
+  -- Two flat lists on purpose. `flat` shrinks as the walk consumes members;
+  -- `full_flat` stays pinned to the caller's original list and is what
+  -- reaches `build_minor_doms`, so `is_rec_field` sees EVERY block member
+  -- when matching spec_params. Passing the shrinking list down instead
+  -- would make a later member's ctor-field classification blind to the
+  -- members already consumed, silently dropping their induction hypotheses.
+  fn build_all_minors_walk(flat: List‹(Addr, G, List‹KExpr›, List‹KLevel›)›,
+                                 full_flat: List‹(Addr, G, List‹KExpr›, List‹KLevel›)›,
+                                 flat_own_params: List‹G›,
+                                 n_rec_params: G, n_motives: G,
+                                 motive_base: G, prev_minors: G,
+                                 mem_pos: G) -> List‹KExpr› {
+    match load(flat) {
+      ListNode.Nil => store(ListNode.Nil),
+      ListNode.Cons(m, rest) =>
+        match m {
+          (member_addr, is_aux, spec_params, occ_us) =>
+            let ci = load(get_ci(member_addr));
+            match ci {
+              KConstantInfo.Induct(_, _, _, _, num_ctors, _,
+                                     mem_block_addr, mem_ind_idx) =>
+                let m_minors = build_minor_doms(member_addr, is_aux,
+                  spec_params, occ_us, full_flat, flat_own_params,
+                  n_rec_params, n_motives, motive_base, mem_pos,
+                  mem_block_addr, mem_ind_idx, num_ctors, prev_minors, 0);
+                let added = list_length(m_minors);
+                let rest_minors = build_all_minors_walk(rest, full_flat,
+                  flat_own_params, n_rec_params, n_motives, motive_base,
+                  prev_minors + added, mem_pos + 1);
+                list_concat(m_minors, rest_minors),
+              _ =>
+                build_all_minors_walk(rest, full_flat, flat_own_params,
+                  n_rec_params, n_motives, motive_base, prev_minors,
+                  mem_pos + 1),
+            },
+        },
+    }
+  }
+
+  -- Peel n Foralls; per-index substitution.
+  --   non-aux: BVar(depth - 1 - j).
+  --   aux: spec_params[j] lifted by spec_lift when j < |spec|, else
+  --        BVar(depth - 1 - j).
+  fn ctor_subst_param_for(j: G, depth: G, spec_lift: G, is_aux: G,
+                                spec_params: List‹KExpr›) -> KExpr {
+    match is_aux {
+      0 => store(KExprNode.BVar((depth - 1) - j)),
+      _ =>
+        let len = list_length(spec_params);
+        match u32_less_than(j, len) {
+          1 => expr_lift(list_lookup(spec_params, j), spec_lift, 0),
+          _ => store(KExprNode.BVar((depth - 1) - j)),
+        },
+    }
+  }
+
+  -- Count remaining leading Foralls in a type (until non-Forall).
+  fn count_foralls_body(ty: KExpr, acc: G) -> G {
+    match load(ty) {
+      KExprNode.Forall(_, body) => count_foralls_body(body, acc + 1),
+      _ => acc,
+    }
+  }
+
+  -- Peel ctor's own_params with depth-aware substitution. For non-aux:
+  -- BVar(depth-1-j). For aux: spec_params[j] lifted by `spec_lift`
+  -- (binders between the recursor-param frame and the peel point — NOT
+  -- `depth`, which counts the params themselves too) when j < |spec|;
+  -- BVar(depth-1-j) otherwise.
+  fn peel_ctor_params_subst(ty: KExpr, n: G, depth: G, spec_lift: G,
+                                  is_aux: G, spec_params: List‹KExpr›,
+                                  j: G) -> KExpr {
+    match n {
+      0 => ty,
+      _ =>
+        -- Structural first, reduce only as a fallback: a constructor's
+        -- parameter binder can hide behind a definitional wrapper, and
+        -- stopping short there builds a minor premise with fewer binders
+        -- than the constructor actually has.
+        match load(ty) {
+          KExprNode.Forall(_, body) =>
+            let p = ctor_subst_param_for(j, depth, spec_lift, is_aux,
+              spec_params);
+            let body_substed = expr_inst1(body, p, 0);
+            peel_ctor_params_subst(body_substed, n - 1, depth,
+              spec_lift, is_aux, spec_params, j + 1),
+          _ =>
+            match load(whnf(ty, store(ListNode.Nil))) {
+              KExprNode.Forall(_, body) =>
+                let p = ctor_subst_param_for(j, depth, spec_lift, is_aux,
+                  spec_params);
+                let body_substed = expr_inst1(body, p, 0);
+                peel_ctor_params_subst(body_substed, n - 1, depth,
+                  spec_lift, is_aux, spec_params, j + 1),
+            },
+        },
+    }
+  }
+
+  -- Build minor binder type for one ctor. Mirror build_minor_at_depth
+  -- (Inductive.lean:928-986).
+  fn build_minor_at_depth(ctor_addr: Addr, ctor_ty: KExpr,
+                                n_own_params: G,
+                                is_aux: G, spec_params: List‹KExpr›,
+                                occurrence_us: List‹KLevel›,
+                                flat: List‹(Addr, G, List‹KExpr›, List‹KLevel›)›,
+                                flat_own_params: List‹G›,
+                                n_rec_params: G, n_motives: G,
+                                prev_minors: G, motive_base: G,
+                                self_mem_idx: G) -> KExpr {
+    let ctor_ty_inst = expr_inst_levels(ctor_ty, occurrence_us);
+    let minor_saved = n_rec_params + n_motives + prev_minors;
+    let below_params = n_motives + prev_minors;
+    let after_params = peel_ctor_params_subst(ctor_ty_inst, n_own_params,
+      minor_saved, below_params, is_aux, spec_params, 0);
+    match walk_fields_classify(after_params, flat, store(ListNode.Nil),
+            store(ListNode.Nil), store(ListNode.Nil), 0, below_params) {
+      (field_doms, rec_indices, rec_member_idxs, ret_ty) =>
+        let n_fields = list_length(field_doms);
+        let n_ihs = list_length(rec_indices);
+        let n_binders = n_fields + n_ihs;
+        let depth_now = minor_saved + n_binders;
+        match collect_spine(ret_ty) {
+          (_ret_head, ret_args) =>
+            let ret_indices = list_drop(ret_args, n_own_params);
+            let ret_indices_lifted = list_lift_each(ret_indices, n_ihs, 0);
+            let motive_var = (depth_now - 1) - (motive_base + self_mem_idx);
+            let motive_ref = store(KExprNode.BVar(motive_var));
+            let with_indices = apply_spine_expr(motive_ref,
+              ret_indices_lifted);
+            let ctor_head = store(KExprNode.Const(ctor_addr, occurrence_us));
+            let with_params = build_ctor_app_params(ctor_head,
+              n_own_params, n_rec_params, depth_now, is_aux, spec_params);
+            let ctor_app = build_apply_field_bvars(with_params,
+              n_fields, n_binders, 0);
+            let conclusion = store(KExprNode.App(with_indices, ctor_app));
+            let ih_doms = build_ih_doms(rec_indices, rec_member_idxs,
+              field_doms, flat_own_params, motive_base, n_fields,
+              minor_saved, 0);
+            let with_ihs = wrap_foralls(conclusion, ih_doms);
+            wrap_foralls(with_ihs, field_doms),
+        },
+    }
+  }
+
+  -- Peel leading Foralls off `ty`, return (forall_doms, body).
+  fn peel_leading_foralls(ty: KExpr) -> (List‹KExpr›, KExpr) {
+    let pair = peel_leading_foralls_acc(ty, store(ListNode.Nil));
+    match pair {
+      (rev_acc, body) => (list_reverse(rev_acc), body),
+    }
+  }
+
+  fn peel_leading_foralls_acc(ty: KExpr, acc: List‹KExpr›)
+                                    -> (List‹KExpr›, KExpr) {
+    match load(ty) {
+      KExprNode.Forall(dom, body) =>
+        peel_leading_foralls_acc(body, store(ListNode.Cons(dom, acc))),
+      _ => (acc, ty),
+    }
+  }
+
+  fn build_apply_xs(head: KExpr, n_xs: G, i: G) -> KExpr {
+    match n_xs - i {
+      0 => head,
+      _ =>
+        let v = store(KExprNode.BVar((n_xs - 1) - i));
+        build_apply_xs(store(KExprNode.App(head, v)), n_xs, i + 1),
+    }
+  }
+
+  -- Build IH dom per rec field. IH shape:
+  --   ∀ (xs from Forall-in-dom peel), motive_ref (lifted_idx_args) (field_ref applied to xs)
+  -- Mirror build_ih_doms (Inductive.lean:3286+).
+  fn build_ih_doms(rec_indices: List‹G›, rec_member_idxs: List‹G›,
+                        field_doms: List‹KExpr›,
+                        flat_own_params: List‹G›,
+                        motive_base: G, n_fields: G, minor_saved: G,
+                        k: G) -> List‹KExpr› {
+    match load(rec_indices) {
+      ListNode.Nil => store(ListNode.Nil),
+      ListNode.Cons(field_idx, rest) =>
+        let mem_idx = list_lookup_or_default(rec_member_idxs, k, 0);
+        let target_n_params = list_lookup_or_default(flat_own_params,
+          mem_idx, 0);
+        let depth = minor_saved + n_fields + k;
+        let dom = list_lookup(field_doms, field_idx);
+        let dom_lifted = expr_lift(dom, (n_fields - field_idx) + k, 0);
+        match peel_leading_foralls(dom_lifted) {
+          (forall_doms, inner_body) =>
+            let n_xs = list_length(forall_doms);
+            let inner_depth = depth + n_xs;
+            let motive_bvar = (inner_depth - 1) - (motive_base + mem_idx);
+            let field_bvar = (inner_depth - 1) - (minor_saved + field_idx);
+            -- Reduce before reading the spine: a recursive field written
+            -- through a reducible wrapper (`Box M`) has that wrapper as its
+            -- head, so its argument would be taken for an index and the
+            -- induction hypothesis would apply the motive to one argument
+            -- too many.
+            match collect_spine(whnf(inner_body, store(ListNode.Nil))) {
+              (_h, dom_args) =>
+                let idx_args = list_drop(dom_args, target_n_params);
+                let motive_ref = store(KExprNode.BVar(motive_bvar));
+                let with_indices = apply_spine_expr(motive_ref, idx_args);
+                let field_ref = store(KExprNode.BVar(field_bvar));
+                let field_app = build_apply_xs(field_ref, n_xs, 0);
+                let ih_body = store(KExprNode.App(with_indices, field_app));
+                let ih_dom = wrap_foralls(ih_body, forall_doms);
+                store(ListNode.Cons(ih_dom,
+                  build_ih_doms(rest, rec_member_idxs, field_doms,
+                    flat_own_params, motive_base, n_fields, minor_saved,
+                    k + 1))),
+            },
+        },
+    }
+  }
+
+  -- Lift each expr in a list by (shift, cutoff).
+  fn list_lift_each(es: List‹KExpr›, shift: G, cutoff: G)
+                          -> List‹KExpr› {
+    match load(es) {
+      ListNode.Nil => store(ListNode.Nil),
+      ListNode.Cons(e, rest) =>
+        store(ListNode.Cons(expr_lift(e, shift, cutoff),
+          list_lift_each(rest, shift, cutoff))),
+    }
+  }
+
+  -- Apply head to BVars at descending positions: BVar(start), BVar(start-1),
+  -- ..., BVar(start - n + 1).
+  fn build_apply_bvars_decreasing(head: KExpr, n: G, start: G,
+                                        j: G) -> KExpr {
+    match n - j {
+      0 => head,
+      _ =>
+        let v = store(KExprNode.BVar(start - j));
+        build_apply_bvars_decreasing(store(KExprNode.App(head, v)),
+          n, start, j + 1),
+    }
+  }
+
+  -- Apply head to ctor fields at BVar(n_binders-1)..BVar(n_binders-nf).
+  fn build_apply_field_bvars(head: KExpr, n_fields: G, n_binders: G,
+                                   i: G) -> KExpr {
+    match n_fields - i {
+      0 => head,
+      _ =>
+        let v = store(KExprNode.BVar((n_binders - 1) - i));
+        build_apply_field_bvars(store(KExprNode.App(head, v)),
+          n_fields, n_binders, i + 1),
+    }
+  }
+
+  -- Build ctor app with own_params: non-aux uses recursor param BVars,
+  -- aux uses spec_params lifted.
+  fn build_ctor_app_params(head: KExpr, n_own_params: G, n_rec_params: G,
+                                 depth_now: G, is_aux: G,
+                                 spec_params: List‹KExpr›) -> KExpr {
+    match is_aux {
+      0 => build_apply_bvars_decreasing(head, n_rec_params,
+             depth_now - 1, 0),
+      _ => apply_spec_params_lifted(head, spec_params,
+             depth_now - n_rec_params),
+    }
+  }
+
+  -- Given a field dom, check if it targets a flat member. Returns
+  -- (found=0/1, mem_pos). For non-aux member: dom's head Const addr
+  -- equals member's addr. For aux member: additionally dom's spine
+  -- args[0..|spec_params|) match spec_params (each lifted by
+  -- spec_lift_by binders). Nested-forall dom (Acc.intro's h :
+  -- ∀ y, r y x → Acc r y) — peel leading Foralls until ret type
+  -- and check its head.
+  fn is_rec_field(dom: KExpr,
+                       flat: List‹(Addr, G, List‹KExpr›, List‹KLevel›)›,
+                       spec_lift_by: G) -> (G, G) {
+    is_rec_field_peel(dom, flat, spec_lift_by)
+  }
+
+  -- WHNF, peel ONE Forall, repeat. Reducing at every peel is what
+  -- exposes an inductive head written behind a reducible definition
+  -- (`abbrev Box a := a` used as a ctor field `Box T`) and index binders
+  -- hidden under definitional wrappers. Without it such a field is
+  -- classified NOT recursive, the reconstructed rule omits its induction
+  -- hypothesis, and `compare_rules` then disagrees with the real
+  -- recursor.
+  --
+  -- WHNF runs in the EMPTY context on purpose: the peeled binder domains
+  -- are deliberately not pushed. The body's loose BVars (field locals and
+  -- the caller frame's param refs) are stuck under whnf either way, and a
+  -- context built from local doms violates ctx-trim's frame
+  -- well-formedness — a param-referencing dom's lbr exceeds the depth
+  -- below it, running the context cut off the end of the list.
+  fn is_rec_field_peel(ty: KExpr, flat: List‹(Addr, G, List‹KExpr›, List‹KLevel›)›,
+                            spec_lift_by: G) -> (G, G) {
+    let w = whnf(ty, store(ListNode.Nil));
+    match load(w) {
+      KExprNode.Forall(_, body) =>
+        is_rec_field_peel(body, flat, spec_lift_by),
+      _ =>
+        match collect_spine(w) {
+          (head, args) =>
+            match load(head) {
+              KExprNode.Const(caddr, _) =>
+                flat_find_matching(flat, caddr, args, spec_lift_by, 0),
+              _ => (0, 0),
+            },
+        },
+    }
+  }
+
+  fn peel_leading_foralls_body(e: KExpr) -> KExpr {
+    match load(e) {
+      KExprNode.Forall(_, body) => peel_leading_foralls_body(body),
+      _ => e,
+    }
+  }
+
+  -- Walk flat, find entry whose addr matches AND (for aux) whose
+  -- spec_params match dom_args' prefix (lifted).
+  fn flat_find_matching(flat: List‹(Addr, G, List‹KExpr›, List‹KLevel›)›,
+                              caddr: Addr, dom_args: List‹KExpr›,
+                              spec_lift_by: G, pos: G) -> (G, G) {
+    match load(flat) {
+      ListNode.Nil => (0, 0),
+      ListNode.Cons(m, rest) =>
+        match m {
+          (member_addr, is_aux, sp, _) =>
+            let addr_match = address_eq(member_addr, caddr);
+            let spec_match = match is_aux {
+              0 => 1,
+              _ => spec_params_dom_prefix_match(sp, dom_args,
+                     spec_lift_by),
+            };
+            match addr_match * spec_match {
+              1 => (1, pos),
+              _ => flat_find_matching(rest, caddr, dom_args,
+                     spec_lift_by, pos + 1),
+            },
+        },
+    }
+  }
+
+  -- Compare spec_params (lifted) against the dom_args prefix. FAIL-OPEN:
+  -- a wrong "no match" makes `is_rec_field` answer "not recursive",
+  -- omitting an induction hypothesis from the reconstructed rule. The
+  -- lifted spec param need not be pointer-identical to the argument even
+  -- when structurally equal, so compare structurally.
+  fn spec_params_dom_prefix_match(sp: List‹KExpr›,
+                                        args: List‹KExpr›,
+                                        lift_by: G) -> G {
+    match load(sp) {
+      ListNode.Nil => 1,
+      ListNode.Cons(s, sr) =>
+        match load(args) {
+          ListNode.Nil => 0,
+          ListNode.Cons(a, ar) =>
+            let s_lifted = expr_lift(s, lift_by, 0);
+            match kexpr_struct_eq(s_lifted, a) {
+              1 => spec_params_dom_prefix_match(sr, ar, lift_by),
+              _ => 0,
+            },
+        },
+    }
+  }
+
+  -- Walk ctor body's field Foralls, collect (field_doms, rec_indices,
+  -- rec_member_idxs, ret_ty). Field is recursive iff dom targets a
+  -- flat member.
+  fn walk_fields_classify(ty: KExpr,
+                                flat: List‹(Addr, G, List‹KExpr›, List‹KLevel›)›,
+                                doms_acc: List‹KExpr›, rec_acc: List‹G›,
+                                rec_mem_acc: List‹G›,
+                                fidx: G, spec_lift_by: G)
+                                -> (List‹KExpr›, List‹G›, List‹G›, KExpr) {
+    match load(ty) {
+      KExprNode.Forall(dom, body) =>
+        -- The lift grows with the field walk. `spec_params` live in the
+        -- recursor-param frame; each field descended past adds one binder
+        -- between that frame and this domain, so they must be lifted by
+        -- `spec_lift_by + fidx` to compare against the domain's argument
+        -- prefix. The `+ fidx` is load-bearing: without it every recursive
+        -- field after the first fails to match its aux flat member and
+        -- silently loses its induction hypothesis.
+        let r = is_rec_field(dom, flat, spec_lift_by + fidx);
+        let new_doms = store(ListNode.Cons(dom, doms_acc));
+        match r {
+          (1, mem_idx) =>
+            let new_rec = store(ListNode.Cons(fidx, rec_acc));
+            let new_mem = store(ListNode.Cons(mem_idx, rec_mem_acc));
+            walk_fields_classify(body, flat, new_doms, new_rec,
+              new_mem, fidx + 1, spec_lift_by),
+          _ =>
+            walk_fields_classify(body, flat, new_doms, rec_acc,
+              rec_mem_acc, fidx + 1, spec_lift_by),
+        },
+      _ => (list_reverse(doms_acc), list_reverse(rec_acc),
+              list_reverse(rec_mem_acc), ty),
+    }
+  }
+
+  fn build_all_motives_walk(flat: List‹(Addr, G, List‹KExpr›, List‹KLevel›)›,
+                                  elim_level: KLevel, n_rec_params: G,
+                                  j: G) -> List‹KExpr› {
+    match load(flat) {
+      ListNode.Nil => store(ListNode.Nil),
+      ListNode.Cons(m, rest) =>
+        match m {
+          (member_addr, is_aux, spec_params, occ_us) =>
+            let ci = load(get_ci(member_addr));
+            match ci {
+              KConstantInfo.Induct(_, m_ind_ty, m_own_params, m_n_indices,
+                                     _, _, _, _) =>
+                let mt = build_motive_type_flat(member_addr, m_ind_ty,
+                  m_own_params, m_n_indices, occ_us, elim_level,
+                  n_rec_params, is_aux, spec_params);
+                let mt_lifted = expr_lift(mt, j, 0);
+                store(ListNode.Cons(mt_lifted,
+                  build_all_motives_walk(rest, elim_level, n_rec_params,
+                    j + 1))),
+              _ =>
+                build_all_motives_walk(rest, elim_level, n_rec_params, j),
+            },
+        },
+    }
+  }
+
+  -- Synthesize aux ctor's body-typed form: peel n_own_params Foralls,
+  -- substitute the peeled BVars with spec_params (each spec_param lives
+  -- in recursor's outer scope — no lift needed when substituted at
+  -- depth 0 within the peeled body).
+  fn synth_aux_ctor_ty(ctor_ty: KExpr, n_own_params: G,
+                             spec_params: List‹KExpr›) -> KExpr {
+    let after_params = peel_n_foralls_tolerant(ctor_ty, n_own_params);
+    -- BVars 0..n_own_params-1 in `after_params` refer to peeled param
+    -- Foralls (innermost = last-peeled). expr_inst_many substitutes
+    -- BVar(depth), BVar(depth+1), ..., BVar(depth+n-1) with substs[0],
+    -- ..., substs[n-1]. Order matters: peel outermost first, so
+    -- outermost peel-target = BVar(n_own_params-1). Reverse spec_params
+    -- so substs[0] matches BVar(0) = innermost peel-target.
+    expr_inst_many(after_params, list_reverse(spec_params), 0)
+  }
+
+  -- Aux canonical rhs: input ctor_body = synth_aux_ctor_ty's result
+  -- (params substituted, ready to walk fields). Uses rec's own n_p
+  -- (not ext's) for body_depth. Detection block_addrs includes BOTH
+  -- rec_block_addr (for own-block direct-rec fields via peer recursor)
+  -- AND parent_block_addr (for aux-self-recursion via ext parent).
+  fn canonical_aux_body(cidx: G, num_ctors: G, rec_np: G, rec_ni: G,
+                              nf: G, ctor_body: KExpr,
+                              rec_block_addr: Addr,
+                              parent_block_addr: Addr,
+                              rec_self_addr: Addr, rec_nlvls: G) -> KExpr {
+    let base = canonical_norec_body(cidx, num_ctors, rec_np, nf);
+    let body_depth = (rec_np + 1 + num_ctors) + nf;
+    let block_addrs = store(ListNode.Cons(rec_block_addr,
+      store(ListNode.Cons(parent_block_addr, store(ListNode.Nil)))));
+    let rec_infos = walk_fields_multi(ctor_body, block_addrs, 0);
+    apply_ihs(base, rec_infos, rec_np, rec_ni, nf, body_depth,
+      num_ctors, rec_block_addr, rec_self_addr, rec_nlvls)
+  }
+
+  fn walk_fields_multi(ty: KExpr, block_addrs: List‹Addr›,
+                            field_pos: G) -> List‹(G, KExpr)› {
+    match load(ty) {
+      KExprNode.Forall(dom, body) =>
+        let mentions = expr_mentions_block(dom, block_addrs);
+        let is_direct_rec = match mentions {
+          0 => 0,
+          _ => is_direct_rec_dom(dom),
+        };
+        let rest = walk_fields_multi(body, block_addrs, field_pos + 1);
+        match is_direct_rec {
+          1 => store(ListNode.Cons((field_pos, dom), rest)),
+          _ => rest,
+        },
+      _ => store(ListNode.Nil),
+    }
+  }
+
+
+  fn check_recursor_member(rec_ci: KConstantInfo, addr: Addr) {
+    match rec_ci {
+      KConstantInfo.Rec(nlvls, ty, n_p, n_i, n_mot, n_min, rules, k_flag,
+                          _uns, rec_block_addr, _rec_idx) =>
+        let parent_addr = rec_to_parent_addr(ty, n_p, n_mot, n_min, n_i);
+        let parent_ci = load(get_ci(parent_addr));
+        match parent_ci {
+          KConstantInfo.Induct(_parent_nlvls, _, parent_np, parent_ni,
+                                 num_ctors, _,
+                                 parent_block_addr, parent_ind_idx) =>
+            -- Aux iff rec's block_addr != parent's block_addr (parent
+            -- is external — an aux member of rec's block for nested-ext
+            -- traversal). Aux recursors have different arities than the
+            -- ext parent (spec_params absorbed); shape checks against
+            -- parent's arity don't apply. Keep only well-scoped +
+            -- rule-count sanity.
+            -- Aux only when BOTH rec's and parent's blocks are Muts,
+            -- and they differ. Anon representations may wrap a single
+            -- Recr in a singleton Muts with parent stored standalone
+            -- — that's not "aux", just anonymization.
+            let is_aux = is_muts_block(rec_block_addr) *
+              is_muts_block(parent_block_addr) *
+              (1 - address_eq(rec_block_addr, parent_block_addr));
+            assert_eq!(list_length(rules), num_ctors,
+              "recursor rule count differs from the inductive's ctor count");
+            peel_n_foralls(ty,
+              ((n_p + n_mot) + n_min + n_i) + 1);
+            check_rec_rules_wellscoped(rules,
+              n_p + n_mot + n_min, nlvls);
+            -- Arity checks compare against the PARENT's counts, which only
+            -- coincide with the recursor's when it eliminates that parent
+            -- directly. An aux recursor absorbs the nesting's spec params,
+            -- so its arities legitimately differ and these do not apply to
+            -- it. Motive and minor premises, index binders, the major spine
+            -- and the conclusion are covered for BOTH cases by the declared
+            -- type's def-eq against the canonical reconstruction below, so
+            -- skipping these for aux loses nothing.
+            match is_aux {
+              1 => (),
+              _ =>
+                assert_eq!(n_p, parent_np,
+                  "recursor parameter count differs from its inductive's");
+                assert_eq!(n_i, parent_ni,
+                  "recursor index count differs from its inductive's");
+                check_rec_major_spine(ty, n_p, n_mot, n_min, n_i,
+                                           parent_np + parent_ni),
+            };
+            -- Unconditional: neither depends on the recursor eliminating its
+            -- parent directly, and `is_aux` is a function of WHERE the Recr
+            -- was placed, so gating on it let a recursor declared outside its
+            -- parent's block skip both.
+            --
+            -- `k_flag` is not part of the recursor's type, so the def-eq
+            -- check cannot catch a forged one — and a wrong k_flag enables
+            -- K-style reduction that the inductive does not license.
+            let computed_k = compute_k_target(parent_ci, parent_addr);
+            assert_eq!(k_flag, computed_k,
+              "recursor k_flag disagrees with its inductive's K eligibility");
+            -- A recursor's meaning is only well-defined over a well-formed
+            -- inductive: the elimination rules it encodes are derived from
+            -- the ctor telescopes. Under subject-only checking, `<ind>.rec`
+            -- is reachable without ever checking `<ind>` itself (memoized
+            -- per block — the inductive's own check_const hits the same rows).
+            check_parent_inductive_shape(parent_ci);
+            -- Full canonical rules identity check via reference-parallel pipeline.
+            check_recursor_canonical_full(rec_ci, addr, parent_ci, parent_addr),
+        },
+    }
+  }
+
+  fn check_rec_major_spine(ty: KExpr, n_p: G, n_mot: G, n_min: G,
+                                n_i: G, expected_args: G) {
+    let skip = n_p + n_mot + n_min + n_i;
+    let after_skip = peel_n_foralls(ty, skip);
+    match load(after_skip) {
+      KExprNode.Forall(major_ty, _) =>
+        match collect_spine(major_ty) {
+          (_head, args) =>
+            assert_eq!(list_length(args), expected_args,
+              "recursor major premise has the wrong number of spine args");
+            (),
+        },
+    }
+  }
+
+  -- Phase 2b (partial): rule shape sanity.
+  -- Per stored rule:
+  --   * cidx sequences from 0 to num_ctors-1 in order.
+  --   * cidx < num_ctors.
+  --   * num_args == parent ctor's (num_params + num_fields).
+  -- Skips canonical rhs identity (phase 2b-full) — construction requires
+  -- build_rec_type + populate_rules + full aux/nested machinery
+  -- (~2000 LOC positional→addr-first port).
+  -- Solo detection: block_addr == parent addr OR Muts w/ 1 Indc member.
+  fn ctor_has_rec_fields_solo(ctor_ty: KExpr, n_params: G,
+                                    parent_addr: Addr) -> G {
+    let after_params = peel_n_foralls_tolerant(ctor_ty, n_params);
+    let block_addrs = store(ListNode.Cons(parent_addr, store(ListNode.Nil)));
+    scan_fields_for_block_ref(after_params, block_addrs)
+  }
+
+  fn peel_n_foralls_tolerant(e: KExpr, n: G) -> KExpr {
+    match n {
+      0 => e,
+      _ =>
+        match load(e) {
+          KExprNode.Forall(_, body) => peel_n_foralls_tolerant(body, n - 1),
+          _ => e,
+        },
+    }
+  }
+
+  fn scan_fields_for_block_ref(ty: KExpr, block_addrs: List‹Addr›) -> G {
+    match load(ty) {
+      KExprNode.Forall(dom, body) =>
+        match expr_mentions_block(dom, block_addrs) {
+          1 => 1,
+          _ => scan_fields_for_block_ref(body, block_addrs),
+        },
+      _ => 0,
+    }
+  }
+
+  -- Build App(head, BVar(nf-1)) App(_, BVar(nf-2)) ... App(_, BVar(0))
+  fn apply_field_bvars(head: KExpr, nf: G, i: G) -> KExpr {
+    match nf - i {
+      0 => head,
+      _ =>
+        let v = store(KExprNode.BVar((nf - 1) - i));
+        apply_field_bvars(store(KExprNode.App(head, v)), nf, i + 1),
+    }
+  }
+
+  -- Canonical rhs BODY (Lams peeled) for a solo ctor rule (any ctor).
+  -- body_depth = n_p + n_mot(=1) + n_min(=num_ctors) + nf.
+  -- Body: minor applied to fields, then IHs (one per rec field).
+  fn canonical_norec_body(cidx: G, num_ctors: G, n_p: G,
+                                nf: G) -> KExpr {
+    let body_depth = (n_p + 1 + num_ctors) + nf;
+    let minor_var = (body_depth - 1) - ((n_p + 1) + cidx);
+    let minor = store(KExprNode.BVar(minor_var));
+    apply_field_bvars(minor, nf, 0)
+  }
+
+  -- Extended canonical body: adds IHs for rec fields. Handles solo and
+  -- mutual blocks; peer recursor addr resolved per-field via
+  -- find_peer_recursor.
+  fn canonical_body(cidx: G, num_ctors: G, n_p: G, n_i: G,
+                         nf: G, ctor_ty: KExpr, block_addr: Addr,
+                         rec_self_addr: Addr, rec_nlvls: G,
+                         rec_block_addr: Addr) -> KExpr {
+    let base = canonical_norec_body(cidx, num_ctors, n_p, nf);
+    let body_depth = (n_p + 1 + num_ctors) + nf;
+    let rec_infos = collect_rec_field_infos(ctor_ty, n_p, block_addr);
+    apply_ihs(base, rec_infos, n_p, n_i, nf, body_depth,
+      num_ctors, rec_block_addr, rec_self_addr, rec_nlvls)
+  }
+
+  -- Rec field info: (position, dom). Both used by IH construction:
+  -- position for field BVar index, dom for extracting index args.
+  fn collect_rec_field_infos(ty: KExpr, np: G,
+                                   block_addr: Addr) -> List‹(G, KExpr)› {
+    let after_params = peel_n_foralls_tolerant(ty, np);
+    walk_fields_collect_rec_infos(after_params, block_addr, 0)
+  }
+
+  fn walk_fields_collect_rec_infos(ty: KExpr, block_addr: Addr,
+                                        field_pos: G) -> List‹(G, KExpr)› {
+    match load(ty) {
+      KExprNode.Forall(dom, body) =>
+        let block_addrs = store(ListNode.Cons(block_addr,
+          store(ListNode.Nil)));
+        let mentions = expr_mentions_block(dom, block_addrs);
+        let is_direct_rec = match mentions {
+          0 => 0,
+          _ => is_direct_rec_dom(dom),
+        };
+        let rest_infos = walk_fields_collect_rec_infos(body, block_addr,
+          field_pos + 1);
+        match is_direct_rec {
+          1 => store(ListNode.Cons((field_pos, dom), rest_infos)),
+          _ => rest_infos,
+        },
+      _ => store(ListNode.Nil),
+    }
+  }
+
+  -- For each rec field j, append IH_j applied to `head`.
+  -- IH_j = `Const(target_rec, rec_lvls) (params...) (motives...) (minors...) (idx_args) field_j`.
+  -- target_rec = peer_recs[mem_idx] — the recursor for the field's own type.
+  -- Mirror crates/kernel/src/inductive.rs fn build_rule_ih.
+  -- Mirror crates/kernel/src/inductive.rs fn build_rule_ih: WHNF the
+  -- field's lifted dom and the inner body so the head/args reflect the
+  -- true inductive occurrence (after reducing wrappers like
+  -- `constType (n α) (n α)` → `n α`).
+  fn apply_ihs(body: KExpr, rec_infos: List‹(G, KExpr)›,
+                    n_p: G, n_i: G, nf: G, body_depth: G,
+                    num_ctors: G, block_addr: Addr,
+                    rec_self_addr: Addr, rec_nlvls: G) -> KExpr {
+    match load(rec_infos) {
+      ListNode.Nil => body,
+      ListNode.Cons(info, rest) =>
+        match info {
+          (pos, dom) =>
+            let ih = build_ih(pos, dom, n_p, n_i, nf, body_depth,
+              num_ctors, block_addr, rec_self_addr, rec_nlvls);
+            apply_ihs(store(KExprNode.App(body, ih)), rest,
+              n_p, n_i, nf, body_depth, num_ctors, block_addr,
+              rec_self_addr, rec_nlvls),
+        },
+    }
+  }
+
+  -- Build IH with indices extracted from the (lifted) field dom's spine.
+  -- For mutual blocks, dom's head may be a PEER inductive — resolve its
+  -- recursor via find_peer_recursor. For solo, dom's head == parent
+  -- inductive, target rec = self.
+  fn build_ih(pos: G, dom: KExpr, n_p: G, n_i: G, nf: G,
+                   body_depth: G, num_ctors: G, block_addr: Addr,
+                   rec_self_addr: Addr, rec_nlvls: G) -> KExpr {
+    let dom_s1 = expr_lift(dom, nf - pos, 0);
+    let dom_lifted = expr_lift(dom_s1, 1 + num_ctors, nf);
+    let (dom_head, dom_args) = collect_spine(dom_lifted);
+    let target_ind_addr = match load(dom_head) {
+      KExprNode.Const(caddr, _) => caddr,
+      _ => rec_self_addr,
+    };
+    let target_rec_addr = find_peer_recursor(block_addr,
+      target_ind_addr, rec_self_addr);
+    let lvls = build_rec_lvls_list(rec_nlvls, 0);
+    let const_head = store(KExprNode.Const(target_rec_addr, lvls));
+    let with_params = apply_param_bvars(const_head, n_p, body_depth - 1, 0);
+    let motive_bvar = (body_depth - 1) - n_p;
+    let with_motive = store(KExprNode.App(with_params,
+      store(KExprNode.BVar(motive_bvar))));
+    let minor_start = (body_depth - 1) - (n_p + 1);
+    let with_minors = apply_minor_bvars(with_motive, num_ctors,
+      minor_start, 0);
+    let idx_args = list_drop(dom_args, n_p);
+    let with_indices = apply_spine_expr(with_minors, idx_args);
+    let field_bvar = (nf - 1) - pos;
+    store(KExprNode.App(with_indices, store(KExprNode.BVar(field_bvar))))
+  }
+
+  -- Given a target inductive addr and the CHECKING recursor's OWN
+  -- block_addr (Muts wrapper), find the recursor in that block whose
+  -- parsed parent addr matches target. For aux recursors, walking
+  -- rec's own block (not parent's ext block) locates both the aux self
+  -- (for ext-target IHs) and the block members' peer recursors (for
+  -- own-block-target IHs).
+  fn find_peer_recursor(block_addr: Addr, target_ind_addr: Addr,
+                             rec_self_addr: Addr) -> Addr {
+    let block_c = load_verified_constant(block_addr);
+    match block_c {
+      Constant.Mk(info, _, _, _) =>
+        match info {
+          ConstantInfo.Muts(members) =>
+            find_peer_rec_walk(members, members, block_addr,
+              target_ind_addr, rec_self_addr, 0),
+          _ => rec_self_addr,
+        },
+    }
+  }
+
+  fn find_peer_rec_walk(all_members: List‹MutConst›,
+                             cur: List‹MutConst›, block_addr: Addr,
+                             target_ind_addr: Addr, rec_self_addr: Addr,
+                             pos: G) -> Addr {
+    match load(cur) {
+      ListNode.Nil => rec_self_addr,
+      ListNode.Cons(m, rest) =>
+        match m {
+          MutConst.Recr(_) =>
+            -- Get this recursor's wrapper addr + KCI, parse ty for
+            -- its parent inductive addr.
+            let rec_wrapper = projection_addr(all_members, block_addr, pos);
+            let rec_ci = load(get_ci(rec_wrapper));
+            let parent_addr = match rec_ci {
+              KConstantInfo.Rec(_, ty, np, ni, nmot, nmin, _, _, _, _, _) =>
+                rec_to_parent_addr(ty, np, nmot, nmin, ni),
+              _ => rec_self_addr,
+            };
+            match address_eq(parent_addr, target_ind_addr) {
+              1 => rec_wrapper,
+              _ =>
+                find_peer_rec_walk(all_members, rest, block_addr,
+                  target_ind_addr, rec_self_addr, pos + 1),
+            },
+          _ =>
+            find_peer_rec_walk(all_members, rest, block_addr,
+              target_ind_addr, rec_self_addr, pos + 1),
+        },
+    }
+  }
+
+  fn apply_spine_expr(head: KExpr, args: List‹KExpr›) -> KExpr {
+    match load(args) {
+      ListNode.Nil => head,
+      ListNode.Cons(a, rest) =>
+        apply_spine_expr(store(KExprNode.App(head, a)), rest),
+    }
+  }
+
+  -- Walk ctor's fields after peeling np params. For each Forall(dom, ..),
+  -- if dom mentions block AND dom is Const-headed spine (no Forall, no
+  -- other), append field's position. Returns positions of DIRECT-REC
+  -- fields; returns (0, empty) if any complex case detected (bail).
+  fn collect_rec_field_positions(ty: KExpr, np: G, block_addr: Addr,
+                                       field_pos: G) -> List‹G› {
+    let after_params = peel_n_foralls_tolerant(ty, np);
+    walk_fields_collect_rec(after_params, block_addr, 0)
+  }
+
+  fn walk_fields_collect_rec(ty: KExpr, block_addr: Addr,
+                                  field_pos: G) -> List‹G› {
+    match load(ty) {
+      KExprNode.Forall(dom, body) =>
+        let block_addrs = store(ListNode.Cons(block_addr,
+          store(ListNode.Nil)));
+        let mentions = expr_mentions_block(dom, block_addrs);
+        let is_direct_rec = match mentions {
+          0 => 0,
+          _ => is_direct_rec_dom(dom),
+        };
+        let rest_positions = walk_fields_collect_rec(body, block_addr,
+          field_pos + 1);
+        match is_direct_rec {
+          1 => store(ListNode.Cons(field_pos, rest_positions)),
+          _ => rest_positions,
+        },
+      _ => store(ListNode.Nil),
+    }
+  }
+
+  -- Direct-rec: dom = Const-headed spine (no Forall, no other complications).
+  fn is_direct_rec_dom(dom: KExpr) -> G {
+    match load(dom) {
+      KExprNode.Forall(_, _) => 0,
+      _ =>
+        match collect_spine(dom) {
+          (head, _) =>
+            match load(head) {
+              KExprNode.Const(_, _) => 1,
+              _ => 0,
+            },
+        },
+    }
+  }
+
+  -- Apply IH for each rec field position.
+  fn apply_ihs_solo(body: KExpr, rec_positions: List‹G›,
+                        n_p: G, n_i: G, nf: G, body_depth: G,
+                        num_ctors: G, rec_self_addr: Addr,
+                        rec_nlvls: G) -> KExpr {
+    match load(rec_positions) {
+      ListNode.Nil => body,
+      ListNode.Cons(pos, rest) =>
+        let ih = build_ih_solo(pos, n_p, n_i, nf, body_depth,
+          num_ctors, rec_self_addr, rec_nlvls);
+        apply_ihs_solo(store(KExprNode.App(body, ih)), rest,
+          n_p, n_i, nf, body_depth, num_ctors, rec_self_addr,
+          rec_nlvls),
+    }
+  }
+
+  -- Build IH for solo direct-rec field at position `pos`:
+  --   `Rec.self.{Param(0)..Param(nlvls-1)}
+  --     param_0 ... param_{np-1}
+  --     motive
+  --     minor_0 ... minor_{nc-1}
+  --     (indices — skipped for direct-rec, would need dom's spine)
+  --     field_pos`
+  -- Field at BVar(nf-1-pos). motive at BVar(body_depth - 1 - np).
+  -- minor_i at BVar(body_depth - 1 - np - 1 - i). Param_i at
+  -- BVar(body_depth - 1 - i).
+  -- Note: for n_i > 0 direct-rec, would need to extract indices from
+  -- dom's spine; skipping means IH may be wrong for indexed inductives.
+  -- Bail for n_i > 0 by returning a placeholder (comparison fails —
+  -- caller should have filtered).
+  fn build_ih_solo(pos: G, n_p: G, n_i: G, nf: G, body_depth: G,
+                        num_ctors: G, rec_self_addr: Addr,
+                        rec_nlvls: G) -> KExpr {
+    let lvls = build_rec_lvls_list(rec_nlvls, 0);
+    let const_head = store(KExprNode.Const(rec_self_addr, lvls));
+    let with_params = apply_param_bvars(const_head, n_p, body_depth - 1, 0);
+    let motive_bvar = (body_depth - 1) - n_p;
+    let with_motive = store(KExprNode.App(with_params,
+      store(KExprNode.BVar(motive_bvar))));
+    let minor_start = (body_depth - 1) - (n_p + 1);
+    let with_minors = apply_minor_bvars(with_motive, num_ctors,
+      minor_start, 0);
+    -- Skip indices (would need dom-spine extraction; solo direct-rec
+    -- with n_i=0 only for this slice).
+    let field_bvar = (nf - 1) - pos;
+    store(KExprNode.App(with_minors,
+      store(KExprNode.BVar(field_bvar))))
+  }
+
+  fn build_rec_lvls_list(total: G, i: G) -> List‹KLevel› {
+    match total - i {
+      0 => store(ListNode.Nil),
+      _ =>
+        store(ListNode.Cons(
+          store(KLevelNode.Param(i)),
+          build_rec_lvls_list(total, i + 1))),
+    }
+  }
+
+  fn apply_param_bvars(head: KExpr, n: G, start: G, i: G) -> KExpr {
+    match n - i {
+      0 => head,
+      _ =>
+        let v = store(KExprNode.BVar(start - i));
+        apply_param_bvars(store(KExprNode.App(head, v)), n, start, i + 1),
+    }
+  }
+
+  fn apply_minor_bvars(head: KExpr, n: G, start: G, i: G) -> KExpr {
+    match n - i {
+      0 => head,
+      _ =>
+        let v = store(KExprNode.BVar(start - i));
+        apply_minor_bvars(store(KExprNode.App(head, v)), n, start, i + 1),
+    }
+  }
+
+  -- Walk each rule; assert its rhs is well-scoped under depth =
+  -- outer_depth + rule.num_args (nf) and universe-bound nlvls.
+  fn check_rec_rules_wellscoped(rules: List‹KRecRule›,
+                                     outer_depth: G, nlvls: G) {
+    match load(rules) {
+      ListNode.Nil => (),
+      ListNode.Cons(r, rest) =>
+        match r {
+          KRecRule.Mk(_, nf, rhs) =>
+            validate_expr_well_scoped(rhs, outer_depth + nf, nlvls);
+            check_rec_rules_wellscoped(rest, outer_depth, nlvls),
+        },
+    }
+  }
+
+  -- Aux-flavored rule walk: per rule, synth aux ctor_ty (peel + subst
+  -- with spec_params), compute canonical body using rec's own n_p +
+  -- multi-block-addr detection, def_eq compare against stored rhs.
+  fn check_aux_rules_walk(rules: List‹KRecRule›,
+                                parent_block_addr: Addr,
+                                parent_ind_idx: G, num_ctors: G,
+                                expected_cidx: G, parent_np: G,
+                                parent_ni: G, spec_params: List‹KExpr›,
+                                rec_np: G, rec_self_addr: Addr,
+                                rec_nlvls: G,
+                                rec_block_addr: Addr) {
+    match load(rules) {
+      ListNode.Nil => (),
+      ListNode.Cons(r, rest) =>
+        match r {
+          KRecRule.Mk(cidx, num_args, rhs) =>
+            assert_eq!(cidx, expected_cidx,
+              "aux recursor rule is out of ctor order");
+            assert_eq!(u32_less_than(cidx, num_ctors), 1,
+              "aux recursor rule names a ctor index out of range");
+            let ctor_ci = load(get_ci_cprj(parent_block_addr,
+              parent_ind_idx, cidx));
+            match ctor_ci {
+              KConstantInfo.Ctor(_, ctor_ty, _, _, _, _cnp, nf, _) =>
+                assert_eq!(num_args, nf,
+                  "aux recursor rule field count differs from the ctor's");
+                let total_lams = ((rec_np + 1) + num_ctors) + nf;
+                let rhs_body = peel_n_lams(rhs, total_lams);
+                -- Synthesize aux ctor body (params substituted).
+                let aux_ctor_body = synth_aux_ctor_ty(ctor_ty,
+                  parent_np, spec_params);
+                let canonical = canonical_aux_body(cidx, num_ctors,
+                  rec_np, parent_ni, nf, aux_ctor_body, rec_block_addr,
+                  parent_block_addr, rec_self_addr, rec_nlvls);
+                let types = build_dummy_types(total_lams,
+                  store(ListNode.Nil));
+                assert_eq!(k_is_def_eq(rhs_body, canonical, types), 1,
+                  "aux recursor rule rhs differs from canonical reconstruction");
+                check_aux_rules_walk(rest, parent_block_addr,
+                  parent_ind_idx, num_ctors, cidx + 1, parent_np,
+                  parent_ni, spec_params, rec_np, rec_self_addr,
+                  rec_nlvls, rec_block_addr),
+            },
+        },
+    }
+  }
+
+  fn check_rec_rules_walk(rules: List‹KRecRule›,
+                               block_addr: Addr, ind_idx: G,
+                               num_ctors: G, expected_cidx: G,
+                               ni: G, rec_self_addr: Addr,
+                               rec_nlvls: G, is_aux: G,
+                               rec_block_addr: Addr) {
+    match load(rules) {
+      ListNode.Nil => (),
+      ListNode.Cons(r, rest) =>
+        match r {
+          KRecRule.Mk(cidx, num_args, rhs) =>
+            assert_eq!(cidx, expected_cidx,
+              "recursor rule is out of ctor order");
+            assert_eq!(u32_less_than(cidx, num_ctors), 1,
+              "recursor rule names a ctor index out of range");
+            let ctor_ci = load(get_ci_cprj(block_addr, ind_idx, cidx));
+            match ctor_ci {
+              KConstantInfo.Ctor(_, ctor_ty, _, _, _, np, nf, _) =>
+                assert_eq!(num_args, nf,
+                  "recursor rule field count differs from the ctor's");
+                -- Peel ALL outer Lams: n_p (params) + n_mot=1 (motive)
+                -- + num_ctors (minors) + nf (fields).
+                let total_lams = ((np + 1) + num_ctors) + nf;
+                let rhs_body = peel_n_lams(rhs, total_lams);
+                maybe_canonical_norec_check(cidx, num_ctors, np, nf,
+                                                  ctor_ty, rhs_body,
+                                                  block_addr, ind_idx,
+                                                  ni, rec_self_addr,
+                                                  rec_nlvls, is_aux,
+                                                  rec_block_addr);
+                check_rec_rules_walk(rest, block_addr, ind_idx,
+                                          num_ctors, cidx + 1, ni,
+                                          rec_self_addr, rec_nlvls,
+                                          is_aux, rec_block_addr),
+            },
+        },
+    }
+  }
+
+  -- Solo + non-recursive check. Bails if either:
+  --   * parent isn't solo (Muts block w/ >1 Indc);
+  --   * ctor has recursive fields (would require IH construction).
+  -- Otherwise builds canonical body and def_eq compares to stored.
+  fn maybe_canonical_norec_check(cidx: G, num_ctors: G, np: G, nf: G,
+                                       ctor_ty: KExpr, rhs_body: KExpr,
+                                       block_addr: Addr, ind_idx: G,
+                                       ni: G, rec_self_addr: Addr,
+                                       rec_nlvls: G, is_aux: G,
+                                       rec_block_addr: Addr) {
+    -- Bail if aux (needs flat_block/spec_params), if any field is
+    -- nested-ext (dom mentions block but head is not a block-member
+    -- Ind), or Forall-in-dom.
+    let has_complex = ctor_has_complex_rec_field(ctor_ty, np, block_addr);
+    match has_complex {
+      1 => (),
+      _ =>
+        let canonical = canonical_body(cidx, num_ctors, np, ni, nf,
+          ctor_ty, block_addr, rec_self_addr, rec_nlvls, rec_block_addr);
+        let types = build_ctor_rule_types(ctor_ty, np, nf,
+          num_ctors, store(ListNode.Nil));
+        assert_eq!(k_is_def_eq(rhs_body, canonical, types), 1,
+          "non-recursive ctor rule rhs differs from canonical reconstruction");
+        (),
+    }
+  }
+
+  -- Returns 1 if any field is nested-ext or Forall-in-dom.
+  fn ctor_has_complex_rec_field(ctor_ty: KExpr, np: G,
+                                      block_addr: Addr) -> G {
+    let after_params = peel_n_foralls_tolerant(ctor_ty, np);
+    scan_fields_for_complex(after_params, block_addr)
+  }
+
+  fn scan_fields_for_complex(ty: KExpr, block_addr: Addr) -> G {
+    match load(ty) {
+      KExprNode.Forall(dom, body) =>
+        let block_addrs = store(ListNode.Cons(block_addr,
+          store(ListNode.Nil)));
+        let mentions = expr_mentions_block(dom, block_addrs);
+        let is_complex = match mentions {
+          0 => 0,
+          _ => 1 - dom_head_is_block_member(dom, block_addr),
+        };
+        match is_complex {
+          1 => 1,
+          _ => scan_fields_for_complex(body, block_addr),
+        },
+      _ => 0,
+    }
+  }
+
+  -- Returns 1 iff dom's spine head is Const of an Ind whose KCI's
+  -- block_addr matches ours (direct-rec on block member). 0 for Forall,
+  -- non-Const head, or ext-nested Const heads.
+  fn dom_head_is_block_member(dom: KExpr, block_addr: Addr) -> G {
+    match load(dom) {
+      KExprNode.Forall(_, _) => 0,
+      _ =>
+        match collect_spine(dom) {
+          (head, _) =>
+            match load(head) {
+              KExprNode.Const(caddr, _) =>
+                let ci = load(get_ci(caddr));
+                match ci {
+                  KConstantInfo.Induct(_, _, _, _, _, _, ba, _) =>
+                    address_eq(ba, block_addr),
+                  _ => 0,
+                },
+              _ => 0,
+            },
+        },
+    }
+  }
+
+  -- Parent-addr resolution parallels ctor gauntlet's helper.
+  fn ctor_parent_addr(block_addr: Addr, ind_idx: G) -> Addr {
+    -- If block_addr is a Muts wrapper, parent addr = projection_addr
+    -- (IPrj wrapper for the ind at ind_idx). If standalone, parent addr
+    -- = block_addr itself. Detect Muts by loading and matching.
+    let block_c = load_verified_constant(block_addr);
+    match block_c {
+      Constant.Mk(info, _, _, _) =>
+        match info {
+          ConstantInfo.Muts(members) =>
+            projection_addr(members, block_addr, ind_idx),
+          _ => block_addr,
+        },
+    }
+  }
+
+  -- Build a types context for def_eq of rhs_body under body scope:
+  --   [field_nf-1_dom, ..., field_0_dom, minor_{nc-1}_dom, ...,
+  --    minor_0_dom, motive_dom, param_{np-1}_dom, ..., param_0_dom]
+  -- Innermost first (as k_is_def_eq expects). For minimal check we
+  -- only need enough context that k_is_def_eq's BVar-lookup won't
+  -- panic — dummies for shape. Since we're comparing structural BVars
+  -- against BVars (no whnf via ctx needed), types can be all dummies
+  -- (Srt 0) of proper length.
+  fn build_ctor_rule_types(ctor_ty: KExpr, np: G, nf: G,
+                                 num_ctors: G,
+                                 acc: List‹KExpr›) -> List‹KExpr› {
+    -- Length = np + 1 (motive) + num_ctors (minors) + nf (fields).
+    let total = ((np + 1) + num_ctors) + nf;
+    build_dummy_types(total, acc)
+  }
+
+  -- Peel up to `n` Lams, collecting each binder's DOMAIN as we descend.
+  -- The returned list is innermost-first, i.e. exactly the `types` context
+  -- the peeled body needs.
+  --
+  -- This replaces `build_dummy_types` at the rule comparison. The old
+  -- kernel compared the FULL rhs terms in an empty context, where each
+  -- Lam carries its own domain; peeling the binders off and then filling
+  -- the context with `Sort 0` placeholders left every minor and field
+  -- typed as `Prop`, so inference inside `k_is_def_eq` aborted with
+  -- "application of a non-function type" the moment a rule body actually
+  -- applied a minor to its fields. Only bare-`BVar` bodies survived.
+  fn peel_n_lams_collect(e: KExpr, n: G, peeled: G, acc: List‹KExpr›)
+                              -> (KExpr, G, List‹KExpr›) {
+    match n {
+      0 => (e, peeled, acc),
+      _ =>
+        match load(e) {
+          KExprNode.Lam(dom, body) =>
+            peel_n_lams_collect(body, n - 1, peeled + 1,
+              store(ListNode.Cons(dom, acc))),
+          _ => (e, peeled, acc),
+        },
+    }
+  }
+
+  -- DO NOT USE for a context that inference will consult. Every entry is
+  -- `Sort 0`, so any binder looked up through it types as `Prop` and the
+  -- first application of it aborts with "application of a non-function
+  -- type". Use `peel_n_lams_collect` to recover the real domains from the
+  -- term's own binders. Its two remaining callers are in the dead chain
+  -- (`check_aux_rules_walk`, `maybe_canonical_norec_check`) and carry this
+  -- defect latently — fix them if that code is ever revived.
+  fn build_dummy_types(n: G, acc: List‹KExpr›) -> List‹KExpr› {
+    match n {
+      0 => acc,
+      _ =>
+        let dummy = store(KExprNode.Srt(store(KLevelNode.Zero)));
+        build_dummy_types(n - 1, store(ListNode.Cons(dummy, acc))),
+    }
+  }
+
+  -- check_const: dispatch per KConstantInfo variant.
+  fn check_const(ci: KConstantInfo, addr: Addr) {
+    let u = is_unsafe_ci(ci);
+    match ci {
+      KConstantInfo.Axiom(nlvls, ty, _) =>
+        validate_expr_well_scoped(ty, 0, nlvls);
+        k_ensure_sort(ty, store(ListNode.Nil));
+        assert_safety(u, ty),
+      KConstantInfo.Defn(nlvls, ty, val, _, _) =>
+        validate_expr_well_scoped(ty, 0, nlvls);
+        validate_expr_well_scoped(val, 0, nlvls);
+        k_ensure_sort(ty, store(ListNode.Nil));
+        assert_safety(u, ty);
+        assert_safety(u, val);
+        k_check(val, ty, store(ListNode.Nil)),
+      KConstantInfo.Thm(nlvls, ty, val) =>
+        validate_expr_well_scoped(ty, 0, nlvls);
+        validate_expr_well_scoped(val, 0, nlvls);
+        let lvl = k_ensure_sort(ty, store(ListNode.Nil));
+        assert_eq!(level_equal(lvl, store(KLevelNode.Zero)), 1,
+          "theorem's type is not a Prop");
+        assert_safety(u, ty);
+        assert_safety(u, val);
+        k_check(val, ty, store(ListNode.Nil)),
+      KConstantInfo.Opaque(nlvls, ty, val, _) =>
+        validate_expr_well_scoped(ty, 0, nlvls);
+        validate_expr_well_scoped(val, 0, nlvls);
+        k_ensure_sort(ty, store(ListNode.Nil));
+        assert_safety(u, ty);
+        assert_safety(u, val);
+        k_check(val, ty, store(ListNode.Nil)),
+      KConstantInfo.Quot(nlvls, ty, kind) =>
+        validate_expr_well_scoped(ty, 0, nlvls);
+        k_ensure_sort(ty, store(ListNode.Nil));
+        assert_safety(u, ty);
+        check_quot(addr, kind, nlvls, ty),
+      KConstantInfo.Induct(nlvls, ty, n_params, n_indices, num_ctors,
+                            _, ind_block, ind_idx) =>
+        validate_expr_well_scoped(ty, 0, nlvls);
+        k_ensure_sort(ty, store(ListNode.Nil));
+        assert_safety(u, ty);
+        -- Canonical block member ordering (adversarial threat model:
+        -- reordered/alpha-colliding Muts members must be rejected).
+        -- Memoized per block addr — runs once even though every
+        -- member check invokes it.
+        check_canonical_block(ind_block);
+        -- Self-contained shape validation: result sort + the full
+        -- per-ctor gauntlet. Without it, subject-only checking accepts
+        -- an inductive whose badness lives in a ctor const.
+        check_inductive_shape(ty, n_params, n_indices, num_ctors,
+                                   nlvls, ind_block, ind_idx);
+        check_block_peer_param_agreement(ci, addr),
+      KConstantInfo.Ctor(nlvls, ty, block_addr, ind_idx, _cidx,
+                         num_params, num_fields, _) =>
+        validate_expr_well_scoped(ty, 0, nlvls);
+        k_ensure_sort(ty, store(ListNode.Nil));
+        assert_safety(u, ty);
+        let ind_ci = load(ctor_parent_ind_ci(block_addr, ind_idx));
+        match ind_ci {
+          KConstantInfo.Induct(ind_nlvls, ind_ty, ind_n_params,
+                                ind_n_indices, _, _, _, _) =>
+            assert_eq!(num_params, ind_n_params,
+              "ctor parameter count differs from its inductive's");
+            check_param_agreement(ind_ty, ty, ind_n_params);
+            check_ctor_return_type(ty, num_params, ind_n_indices,
+                                        num_fields, ind_nlvls, block_addr,
+                                        ind_idx);
+            let ind_level = get_result_sort_level(ind_ty,
+              ind_n_params + ind_n_indices, store(ListNode.Nil));
+            check_field_universes(ty, num_params, ind_level);
+            check_positivity(ty, num_params, block_addr,
+                                  store(ListNode.Nil)),
+        },
+      KConstantInfo.Rec(nlvls, ty, _, _, _, _, _, _, _, rec_block, _) =>
+        validate_expr_well_scoped(ty, 0, nlvls);
+        k_ensure_sort(ty, store(ListNode.Nil));
+        assert_safety(u, ty);
+        check_canonical_block(rec_block);
+        check_recursor_member(ci, addr),
     }
   }
 ⟧
diff --git a/Ix/IxVM/Kernel/Claim.lean b/Ix/IxVM/Kernel/Claim.lean
index 5e39ef710..741c1efdb 100644
--- a/Ix/IxVM/Kernel/Claim.lean
+++ b/Ix/IxVM/Kernel/Claim.lean
@@ -1,60 +1,508 @@
-/-
-  # Aiur kernel claim dispatcher
-
-  The flow mirrors how constants are loaded: hash the bytes, assert
-  equality with the supplied digest, deserialize once into an Aiur
-  ADT, and use the structured value. No scattered inline-parse
-  comparisons.
-
-      claim_digest ── IOBuffer ─▶ claim_bytes
-                                  │
-                                  ▼
-                          blake3 assert
-                                  │
-                                  ▼
-                           get_claim                    ◀ deserialize
-                                  │
-                                  ▼
-                       match Claim variant              ◀ structured use
-
-  Wire format mirrors `Ix/Claim.lean`:
-
-    Variant 3  EvalClaim       (input output : Addr) (asm : Opt Addr)
-    Variant 4  CheckClaim      (const : Addr)        (asm : Opt Addr)
-    Variant 5  CheckEnvClaim   (root  : Addr)        (asm : Opt Addr)
-    Variant 6  RevealClaim     (comm  : Addr) (info : RevealConstantInfo)
-    Variant 7  ContainsClaim   (tree  : Addr) (const : Addr)
-
-  Eval is the only `run_*` arm still placeholder — Rust kernel has
-  not pinned reduction semantics yet.
--/
 module
 public import Ix.Aiur.Meta
 public import Ix.IxVM.KernelTypes
-public import Ix.IxVM.Ingress
-public import Ix.IxVM.IxonSerialize
-public import Ix.IxVM.IxonDeserialize
 public import Ix.IxVM.Kernel.Check
+public import Ix.IxVM.Ingress
 
 public section
 
 namespace IxVM
 
+/-! ## Claim — the claim-variant runners behind `verify_claim`
+
+`run_claim` parses the claim at ch 0 and dispatches to one of these:
+
+* `run_check` — typecheck a single constant.
+* `run_check_transitive` — a constant plus everything reachable through
+  refs, with no ownership set (Check claims assert nothing about which
+  shard owns what).
+* `run_check_env` — every leaf of an owned merkle tree, walking with an
+  assumption cutoff and a strict owned-membership rule.
+* `run_reveal` — selective field revelation of a committed constant.
+* `run_contains` — merkle membership of a target in a tree.
+-/
+
 def claim := ⟦
+  -- Single-const check. Loads `addr`'s KConstantInfo lazily and
+  -- typechecks it. Every ref discovered during typechecking is
+  -- resolved via nested `get_ci`, faulting bytes from IOBuffer
+  -- on first touch.
+  fn run_check(addr: Addr) {
+    let ci = load(get_ci(addr));
+    check_const(ci, addr)
+  }
+
+  -- Which entries of a constant's `refs` are CONSTANT addresses — the
+  -- indices the walk must recurse into.
+  --
+  -- An address is a constant when an Expr node references it as one:
+  -- `Ref(i, ..)` and `Prj(i, ..)` index a constant, while `Str(i)` and
+  -- `Nat(i)` index a blob payload. An address reached from outside any
+  -- Expr — a claim target, a block address — is a constant reference by
+  -- Ixon convention and is walked by its own path.
+  --
+  -- The rule is deliberately POSITIVE: walk index `i` iff some Expr uses
+  -- it as a constant. The inverse formulation — skip whatever looks like
+  -- a blob — is unsound, because the Exprs are authored by the prover and
+  -- `refs` is one index space shared by all four node kinds. Under that
+  -- rule a single `Nat(i)` node anywhere in the constant suppresses the
+  -- walk of `refs[i]` used as a `Ref` everywhere else, and the entry need
+  -- not even be live: `sharing` is traversed here in full but converted
+  -- only where an `Expr.Share` reaches it, so a dead `Nat(i)` entry costs
+  -- the prover nothing and hides an arbitrary dependency from the
+  -- checker. `k_infer` then reads that dependency's DECLARED type without
+  -- ever checking it, which is a wrong answer rather than an abort.
+  --
+  -- Over-approximating this set is safe: a walk into a non-constant
+  -- address faults an unseeded key and aborts, which only costs a
+  -- dishonest prover. Under-approximating it is not.
+  --
+  -- Note the same BYTES may be readable as both a constant and a Nat or
+  -- utf-8 string; only this Expr context disambiguates, so byte inspection
+  -- could not replace it.
+  -- Direct recursion, no accumulator: each function is a pure function of
+  -- the node it is given, so Aiur memoizes per-pointer and a shared
+  -- subexpression is traversed once no matter how many parents reach it.
+  -- Threading an accumulator would defeat that — the accumulator differs at
+  -- every call site, so no two calls would ever share a memo entry.
+  fn const_idxs_expr(e: &Expr) -> List‹G› {
+    match load(e) {
+      -- `Ref(i, _)` resolves refs[i] as a constant; `Prj(i, _, inner)`
+      -- resolves refs[i] as the projected structure's type constant.
+      -- These two are the ONLY Expr nodes that name a constant through
+      -- the refs table — `Rec` resolves through `recur_addrs`, and a
+      -- projection's block comes from the ConstantInfo payload, both
+      -- walked separately.
+      Expr.Ref(i, _) =>
+        store(ListNode.Cons(flatten_u64(i), store(ListNode.Nil))),
+      Expr.Prj(i, _, inner) =>
+        store(ListNode.Cons(flatten_u64(i), const_idxs_expr(inner))),
+      Expr.App(f, a) => list_concat(const_idxs_expr(f), const_idxs_expr(a)),
+      Expr.Lam(t, b) => list_concat(const_idxs_expr(t), const_idxs_expr(b)),
+      Expr.All(t, b) => list_concat(const_idxs_expr(t), const_idxs_expr(b)),
+      Expr.Let(_, t, v, b) =>
+        list_concat(const_idxs_expr(t),
+          list_concat(const_idxs_expr(v), const_idxs_expr(b))),
+      -- `Share` is deliberately NOT followed: the Expr is a DAG, and
+      -- following share edges expands it exponentially. Every shared
+      -- subexpression is itself an entry in `sharing`, which is walked
+      -- once below, so coverage is complete and the traversal stays linear.
+      _ => store(ListNode.Nil),
+    }
+  }
+
+  fn const_idxs_exprs(es: List‹&Expr›) -> List‹G› {
+    match load(es) {
+      ListNode.Nil => store(ListNode.Nil),
+      ListNode.Cons(e, rest) =>
+        list_concat(const_idxs_expr(e), const_idxs_exprs(rest)),
+    }
+  }
+
+  fn const_idxs_rules(rs: List‹RecursorRule›) -> List‹G› {
+    match load(rs) {
+      ListNode.Nil => store(ListNode.Nil),
+      ListNode.Cons(r, rest) =>
+        match r {
+          RecursorRule.Mk(_, rhs) =>
+            list_concat(const_idxs_expr(rhs), const_idxs_rules(rest)),
+        },
+    }
+  }
+
+  fn const_idxs_ctors(cs: List‹Constructor›) -> List‹G› {
+    match load(cs) {
+      ListNode.Nil => store(ListNode.Nil),
+      ListNode.Cons(c, rest) =>
+        match c {
+          Constructor.Mk(_, _, _, _, _, typ) =>
+            list_concat(const_idxs_expr(typ), const_idxs_ctors(rest)),
+        },
+    }
+  }
+
+  fn const_idxs_muts(ms: List‹MutConst›) -> List‹G› {
+    match load(ms) {
+      ListNode.Nil => store(ListNode.Nil),
+      ListNode.Cons(m, rest) =>
+        match m {
+          MutConst.Defn(d) =>
+            match d {
+              Definition.Mk(_, _, _, typ, value) =>
+                list_concat(
+                  list_concat(const_idxs_expr(typ), const_idxs_expr(value)),
+                  const_idxs_muts(rest)),
+            },
+          MutConst.Indc(i) =>
+            match i {
+              Inductive.Mk(_, _, _, _, typ, ctors) =>
+                list_concat(
+                  list_concat(const_idxs_expr(typ), const_idxs_ctors(ctors)),
+                  const_idxs_muts(rest)),
+            },
+          MutConst.Recr(r) =>
+            match r {
+              Recursor.Mk(_, _, _, _, _, _, _, typ, rules) =>
+                list_concat(
+                  list_concat(const_idxs_expr(typ), const_idxs_rules(rules)),
+                  const_idxs_muts(rest)),
+            },
+        },
+    }
+  }
+
+  fn const_idxs_of(c: Constant) -> List‹G› {
+    match c {
+      Constant.Mk(info, sharing, _, _) =>
+        let shared = const_idxs_exprs(sharing);
+        match info {
+          ConstantInfo.Defn(d) =>
+            match d {
+              Definition.Mk(_, _, _, typ, value) =>
+                list_concat(shared,
+                  list_concat(const_idxs_expr(typ), const_idxs_expr(value))),
+            },
+          ConstantInfo.Recr(r) =>
+            match r {
+              Recursor.Mk(_, _, _, _, _, _, _, typ, rules) =>
+                list_concat(shared,
+                  list_concat(const_idxs_expr(typ), const_idxs_rules(rules))),
+            },
+          ConstantInfo.Axio(a) =>
+            match a {
+              Axiom.Mk(_, _, typ) =>
+                list_concat(shared, const_idxs_expr(typ)),
+            },
+          ConstantInfo.Quot(q) =>
+            match q {
+              Quotient.Mk(_, _, typ) =>
+                list_concat(shared, const_idxs_expr(typ)),
+            },
+          ConstantInfo.Muts(members) =>
+            list_concat(shared, const_idxs_muts(members)),
+          -- Projection wrappers carry no Exprs of their own.
+          _ => shared,
+        },
+    }
+  }
+
+  fn g_list_has(xs: List‹G›, x: G) -> G {
+    match load(xs) {
+      ListNode.Nil => 0,
+      ListNode.Cons(y, rest) =>
+        match y - x {
+          0 => 1,
+          _ => g_list_has(rest, x),
+        },
+    }
+  }
+
+  -- Transitive check: verify `addr` + every constant reachable via
+  -- refs. Refs are BLOCK-level addresses — the acyclic dep DAG lives
+  -- at block granularity (mutual constants inside a single Muts block;
+  -- block refs form a DAG). Aiur memoizes per-addr so shared
+  -- subgraphs check once.
+  --
+  -- Projection wrappers (DPrj/IPrj/CPrj/RPrj) have empty refs of their
+  -- own; the actual dep list lives on their target BLOCK's
+  -- Constant.Mk. Unwrap to the block via run_check_transitive
+  -- recursion, which then walks the block's refs.
+  --
+  -- Every address that reaches here is a CONSTANT: the caller admits only
+  -- indices `const_idxs_of` saw used as constants, and a claim target or a
+  -- block address is a constant reference by convention. The decision to
+  -- check is never taken from IO-buffer metadata.
+  fn run_check_transitive(addr: Addr) {
+    let c = load_verified_constant(addr);
+    match c {
+      Constant.Mk(info, _, refs, _) =>
+        match info {
+          ConstantInfo.Muts(members) =>
+            check_muts_all(addr, members, members, 0),
+          ConstantInfo.DPrj(dprj) =>
+            match dprj {
+              DefinitionProj.Mk(_, block_addr) =>
+                run_check(addr);
+                run_check_transitive(block_addr),
+            },
+          ConstantInfo.IPrj(iprj) =>
+            match iprj {
+              InductiveProj.Mk(_, block_addr) =>
+                run_check(addr);
+                run_check_transitive(block_addr),
+            },
+          ConstantInfo.CPrj(cprj) =>
+            match cprj {
+              ConstructorProj.Mk(_, _, block_addr) =>
+                run_check(addr);
+                run_check_transitive(block_addr),
+            },
+          ConstantInfo.RPrj(rprj) =>
+            match rprj {
+              RecursorProj.Mk(_, block_addr) =>
+                run_check(addr);
+                run_check_transitive(block_addr),
+            },
+          _ => run_check(addr),
+        };
+        walk_refs_transitive(refs, const_idxs_of(c), 0),
+    }
+  }
+
+  -- Recurse into exactly the refs the constant's own Exprs use as
+  -- CONSTANTS; everything else is a blob payload or unreferenced. The
+  -- decision comes from `const_idxs_of`, i.e. from bytes already bound by
+  -- blake3 — not from an IO probe the prover answers.
+  fn walk_refs_transitive(refs: List‹Addr›, consts: List‹G›, i: G) {
+    match load(refs) {
+      ListNode.Nil => (),
+      ListNode.Cons(a, rest) =>
+        match g_list_has(consts, i) {
+          1 => run_check_transitive(a),
+          _ => (),
+        };
+        walk_refs_transitive(rest, consts, i + 1),
+    }
+  }
+
+  -- Check every member of a Muts block. Each member is checked through
+  -- the projection ci (via get_ci_iprj/cprj/rprj/dprj) so all block
+  -- members get their full soundness gauntlet.
+  fn check_muts_all(block_addr: Addr, all_members: List‹MutConst›,
+                          cur: List‹MutConst›, pos: G) {
+    match load(cur) {
+      ListNode.Nil => (),
+      ListNode.Cons(m, rest) =>
+        check_muts_member_at(block_addr, all_members, m, pos);
+        check_muts_all(block_addr, all_members, rest, pos + 1),
+    }
+  }
+
+  fn check_muts_member_at(block_addr: Addr,
+                                all_members: List‹MutConst›,
+                                m: MutConst, pos: G) {
+    let member_addr = projection_addr(all_members, block_addr, pos);
+    let ci = load(get_ci(member_addr));
+    check_const(ci, member_addr)
+  }
+
+  -- ============================================================================
+  -- Assumption / env tree: leaf list serialization (ch 1). The format
+  -- matches the Rust implementation in crates/kernel/src, so the same
+  -- witness buffers feed either checker. The tree is bound to its ch 1
+  -- key by recomputing the merkle root, not by hashing the bytes — see
+  -- the channel table in Ix/IxVM/ClaimHarness.lean.
   -- ============================================================================
-  -- Reveal-specific ADT mirror. `RevealConstantInfo` parallels
-  -- `ConstantInfo` (from `Ix/IxVM/Ixon.lean`) but every payload field
-  -- is wrapped in `Option‹…›` for selective revelation, and Expr
-  -- fields are replaced by their content-hashed `Addr`. The shape is
-  -- a 1:1 copy of `Ix.RevealConstantInfo` in `Ix/Claim.lean`.
+  fn leaf_hash(addr: Addr) -> Addr {
+    let tail = put_address(addr, store(ListNode.Nil));
+    let bytes = store(ListNode.Cons(0u8, tail));
+    bytes_to_addr(bytes)
+  }
+
+  fn node_hash(l: Addr, r: Addr) -> Addr {
+    let tail = put_address(l, put_address(r, store(ListNode.Nil)));
+    let bytes = store(ListNode.Cons(1u8, tail));
+    bytes_to_addr(bytes)
+  }
+
+  -- Assumption-tree parser / loader. Same as constants: load bytes,
+  -- recompute root via merkle fold, assert match.
+  fn parse_atree_body(stream: ByteStream) -> (Addr, List‹Addr›, ByteStream) {
+    let (tag, s) = read_byte(stream);
+    match tag {
+      0 =>
+        let (addr, s2) = get_address(s);
+        let h = leaf_hash(addr);
+        (h, store(ListNode.Cons(addr, store(ListNode.Nil))), s2),
+      1 =>
+        (store([0u8; 32]), store(ListNode.Nil), s),
+      2 =>
+        let (lh, ll, s2) = parse_atree_body(s);
+        let (rh, rl, s3) = parse_atree_body(s2);
+        let h = node_hash(lh, rh);
+        (h, list_concat(ll, rl), s3),
+    }
+  }
+
+  fn load_assumption_tree(root: Addr) -> List‹Addr› {
+    let raw = load(root);
+    let (idx, len) = io_get_info(1, raw);
+    let bytes = #read_byte_stream(1, idx, len);
+    let (tag, s) = get_tag4(bytes);
+    let (flag, size) = tag;
+    assert_eq!(flag, 0xE, "assumption tree: wrong tag4 flag");
+    assert_eq!(to_field(size[0]), 2, "assumption tree: wrong tag4 variant");
+    let (computed_root, leaves, rest) = parse_atree_body(s);
+    assert_eq!(load(rest), ListNode.Nil,
+      "assumption tree: trailing bytes after tree body");
+    let computed_arr = load(computed_root);
+    -- Binds ch 1 to its key: the recomputed merkle root must equal the
+    -- address the tree was requested under.
+    assert_eq!(computed_arr, raw,
+      "assumption tree: recomputed merkle root != requested root");
+    leaves
+  }
+
+  -- ============================================================================
+  -- R1: asm-aware transitive walk. Shared by Check-with-asm and
+  -- CheckEnv. Per visited constant addr:
+  --   * addr ∈ asm: assumed well-typed by its owning shard — do not
+  --     check, do not recurse. The asm tree is the thin FRONTIER of
+  --     the owned closure's out-of-shard refs; the ref-walk can only
+  --     leave the shard through a frontier member, so nothing below
+  --     the frontier is visited. (Bytes below the frontier may still
+  --     be faulted by get_ci during delta unfolding — that is the
+  --     ch 2 byte scope, blake3-bound per addr, and deliberately NOT
+  --     subject to this walk's membership rule.)
+  --   * strict=1 (CheckEnv): addr must be ∈ owned — a walk-reachable
+  --     constant in neither owned nor asm means the claim's owned
+  --     tree does not cover its own closure (bad frontier); abort
+  --     rather than silently absorb the check. Owned trees must list
+  --     the full block-level closure (blocks and wrappers included),
+  --     which is what `AssumptionTree.canonical` over a closure set
+  --     produces.
+  --   * otherwise: check the constant (Muts: every member) and
+  --     recurse its block-level refs.
+  -- Aiur memoizes per (addr, owned, asm, strict) — the list pointers
+  -- are per-run constants, so shared subgraphs walk once.
+  -- Addr-set membership via RBTreeMap keyed on the interned store
+  -- pointer: content-addressed interning makes ptr equality ⇔ 32-byte
+  -- equality in BOTH directions (each content has exactly one store
+  -- slot), so a u32 ptr key is an exact membership test. O(log n) per
+  -- query vs the O(n) list scan — the frontier list is the biggest
+  -- per-visit cost on fat-frontier shards (e.g. 1977 asm leaves).
+  fn addr_set_build(leaves: List‹Addr›, acc: RBTreeMap‹G›) -> RBTreeMap‹G› {
+    match load(leaves) {
+      ListNode.Nil => acc,
+      ListNode.Cons(a, rest) =>
+        addr_set_build(rest, rbtree_map_insert(ptr_val(a), 1, acc)),
+    }
+  }
+
+  fn addr_set_member(a: Addr, tree: RBTreeMap‹G›) -> G {
+    rbtree_map_lookup_or_default(ptr_val(a), tree, 0)
+  }
+
+  fn env_walk(addr: Addr, owned: RBTreeMap‹G›, asm: RBTreeMap‹G›,
+                  strict: G) {
+    -- Every address reaching here is a constant: the caller admits only
+    -- indices the referring constant's own Exprs use as constants, and a
+    -- walk root or block address is a constant reference by convention.
+    -- Nothing here may
+    -- branch on IO-buffer metadata — this walk decides both what gets checked
+    -- and what strict membership covers, so a prover-steerable skip would
+    -- exclude an owned leaf from both while the claim's merkle root still
+    -- commits to it.
+    match addr_set_member(addr, asm) {
+      1 => (),
+      _ =>
+        match strict {
+          1 =>
+            assert_eq!(addr_set_member(addr, owned), 1,
+              "CheckEnv: walk reached a constant outside the owned set");
+            (),
+          _ => (),
+        };
+        let c = load_verified_constant(addr);
+        match c {
+          Constant.Mk(info, _, refs, _) =>
+            match info {
+              ConstantInfo.Muts(members) =>
+                check_muts_all(addr, members, members, 0),
+              ConstantInfo.DPrj(dprj) =>
+                match dprj {
+                  DefinitionProj.Mk(_, block_addr) =>
+                    run_check(addr);
+                    env_walk(block_addr, owned, asm, strict),
+                },
+              ConstantInfo.IPrj(iprj) =>
+                match iprj {
+                  InductiveProj.Mk(_, block_addr) =>
+                    run_check(addr);
+                    env_walk(block_addr, owned, asm, strict),
+                },
+              ConstantInfo.CPrj(cprj) =>
+                match cprj {
+                  ConstructorProj.Mk(_, _, block_addr) =>
+                    run_check(addr);
+                    env_walk(block_addr, owned, asm, strict),
+                },
+              ConstantInfo.RPrj(rprj) =>
+                match rprj {
+                  RecursorProj.Mk(_, block_addr) =>
+                    run_check(addr);
+                    env_walk(block_addr, owned, asm, strict),
+                },
+              _ => run_check(addr),
+            };
+            env_walk_refs(refs, const_idxs_of(c), 0, owned, asm, strict),
+        },
+    }
+  }
+
+  fn env_walk_refs(refs: List‹Addr›, consts: List‹G›, i: G,
+                       owned: RBTreeMap‹G›,
+                       asm: RBTreeMap‹G›, strict: G) {
+    match load(refs) {
+      ListNode.Nil => (),
+      ListNode.Cons(a, rest) =>
+        match g_list_has(consts, i) {
+          1 => env_walk(a, owned, asm, strict),
+          _ => (),
+        };
+        env_walk_refs(rest, consts, i + 1, owned, asm, strict),
+    }
+  }
+
+  fn env_walk_leaves(leaves: List‹Addr›, owned: RBTreeMap‹G›,
+                         asm: RBTreeMap‹G›) {
+    match load(leaves) {
+      ListNode.Nil => (),
+      ListNode.Cons(a, rest) =>
+        env_walk(a, owned, asm, 1);
+        env_walk_leaves(rest, owned, asm),
+    }
+  }
+
+  -- CheckEnv: every owned leaf is checked TRANSITIVELY with the asm
+  -- cutoff and strict owned-membership on the walk set. The walk has to
+  -- be explicit because `get_ci` is lazy and consults a dependency's
+  -- declared type without checking it: being loaded is not evidence of
+  -- being well-typed, so every constant the claim covers must be
+  -- reached by this walk or assumed via the frontier.
+  fn run_check_env(env_root: Addr, asm: Option‹Addr›) {
+    let owned = load_assumption_tree(env_root);
+    let asm_leaves = match asm {
+      Option.None => store(ListNode.Nil),
+      Option.Some(r) => load_assumption_tree(r),
+    };
+    let owned_set = addr_set_build(owned, RBTreeMap.Nil);
+    let asm_set = addr_set_build(asm_leaves, RBTreeMap.Nil);
+    env_walk_leaves(owned, owned_set, asm_set)
+  }
+
+  -- Option<Address> deserializer, mirror (Kernel/Claim.lean:109).
+  fn get_opt_addr(stream: ByteStream) -> (Option‹Addr›, ByteStream) {
+    let (tag, s) = read_byte(stream);
+    match tag {
+      0 => (Option.None, s),
+      1 =>
+        let (addr, s2) = get_address(s);
+        (Option.Some(addr), s2),
+    }
+  }
+
   -- ============================================================================
+  -- Reveal claim (variant 6). Mirrors the Rust implementation in
+  -- crates/kernel/src; the machinery is Ixon-level rather than
+  -- typechecker-level: parse a `RevealConstantInfo` (per-field Option
+  -- mirror of `ConstantInfo`, Expr fields as content hashes), load the
+  -- committed constant, assert every Some(field) equals the real one.
 
-  -- (ruleIdx, fields, rhs_addr). `rhs_addr` = blake3(put_expr rhs).
   enum RevealRecursorRule {
     Mk(U64, U64, Addr)
   }
 
-  -- (isUnsafe, lvls, cidx, params, fields, typ).
   enum RevealConstructorInfo {
     Mk(Option‹G›, Option‹U64›, Option‹U64›,
        Option‹U64›, Option‹U64›, Option‹Addr›)
@@ -89,33 +537,6 @@ def claim := ⟦
     Muts(List‹(U64, RevealMutConstInfo)›)
   }
 
-  -- The full claim ADT — parallels `Ix.Claim` in `Ix/Claim.lean`.
-  enum Claim {
-    Eval(Addr, Addr, Option‹Addr›),
-    Check(Addr, Option‹Addr›),
-    CheckEnv(Addr, Option‹Addr›),
-    Reveal(Addr, RevealConstantInfo),
-    Contains(Addr, Addr)
-  }
-
-  -- ============================================================================
-  -- Wire-format helpers shared across the deserializers.
-  -- ============================================================================
-
-  -- `Option<Address>` per `Ix/Claim.lean::putOptAddr` (top-level
-  -- `assumptions` slot, NOT the bitmask-gated reveal-fields form).
-  --   [0x00]              → none
-  --   [0x01][addr:32]     → some addr
-  fn get_opt_addr(stream: ByteStream) -> (Option‹Addr›, ByteStream) {
-    let (tag, s) = read_byte(stream);
-    match tag {
-      0 => (Option.None, s),
-      1 =>
-        let (addr, s2) = get_address(s);
-        (Option.Some(addr), s2),
-    }
-  }
-
   -- Bitmask-gated decoders for the per-field Reveal payloads.
   fn get_opt_u64_masked(mb: G, stream: ByteStream)
       -> (Option‹U64›, ByteStream) {
@@ -190,10 +611,8 @@ def claim := ⟦
     }
   }
 
-  -- ============================================================================
   -- RevealRecursorRule list parser.
   -- Wire: `Tag0(count) + count × (Tag0(idx) + Tag0(fields) + Address)`.
-  -- ============================================================================
   fn get_reveal_rule(stream: ByteStream) -> (RevealRecursorRule, ByteStream) {
     let (rule_idx, s) = get_tag0(stream);
     let (fields, s) = get_tag0(s);
@@ -223,9 +642,7 @@ def claim := ⟦
     }
   }
 
-  -- ============================================================================
   -- RevealConstructorInfo parser. 6 optional fields, mask bits 0..5.
-  -- ============================================================================
   fn get_reveal_ctor_info(stream: ByteStream)
       -> (RevealConstructorInfo, ByteStream) {
     let (mask, s) = get_tag0(stream);
@@ -269,9 +686,7 @@ def claim := ⟦
     }
   }
 
-  -- ============================================================================
   -- RevealMutConstInfo parser. variant + mask + per-bit fields.
-  -- ============================================================================
   fn get_reveal_mut_const_info(stream: ByteStream)
       -> (RevealMutConstInfo, ByteStream) {
     let (variant, s) = read_byte(stream);
@@ -330,9 +745,7 @@ def claim := ⟦
     }
   }
 
-  -- ============================================================================
   -- RevealConstantInfo parser. `variant + mask:Tag0 + per-bit fields`.
-  -- ============================================================================
   fn get_reveal_info(stream: ByteStream) -> (RevealConstantInfo, ByteStream) {
     let (variant, s) = read_byte(stream);
     let (mask, s) = get_tag0(s);
@@ -398,68 +811,14 @@ def claim := ⟦
     }
   }
 
-  -- ============================================================================
-  -- Claim parser. Parses Tag4(0xE, variant) wrapper + per-variant
-  -- payload into the `Claim` ADT.
-  -- ============================================================================
-  fn get_claim(bytes: ByteStream) -> (Claim, ByteStream) {
-    let (tag, s) = get_tag4(bytes);
-    let (flag, size) = tag;
-    assert_eq!(flag, 0xE);
-    let variant = size[0];
-    match variant {
-      3 =>
-        let (input, s) = get_address(s);
-        let (output, s) = get_address(s);
-        let (asm, s) = get_opt_addr(s);
-        (Claim.Eval(input, output, asm), s),
-      4 =>
-        let (c, s) = get_address(s);
-        let (asm, s) = get_opt_addr(s);
-        (Claim.Check(c, asm), s),
-      5 =>
-        let (root, s) = get_address(s);
-        let (asm, s) = get_opt_addr(s);
-        (Claim.CheckEnv(root, asm), s),
-      6 =>
-        let (comm, s) = get_address(s);
-        let (info, s) = get_reveal_info(s);
-        (Claim.Reveal(comm, info), s),
-      7 =>
-        let (tree, s) = get_address(s);
-        let (target, s) = get_address(s);
-        (Claim.Contains(tree, target), s),
-    }
-  }
-
-  -- Load + verify a claim from the IOBuffer at key=`digest`. Mirrors
-  -- `load_verified_constant`: read bytes, recompute blake3, assert
-  -- equality, deserialize, assert no trailing data.
-  -- Load + verify a claim from IOBuffer at `digest` (ch 0). Reads bytes,
-  -- recomputes blake3, asserts equality, deserialises.
-  fn load_verified_claim(digest: [U8; 32]) -> Claim {
-    let (idx, len) = io_get_info(0, digest);
-    let bytes = #read_byte_stream(0, idx, len);
-    verify_bytes_against(bytes, digest);
-    let (claim, rest) = get_claim(bytes);
-    assert_eq!(load(rest), ListNode.Nil);
-    claim
-  }
-
-  -- ============================================================================
-  -- Content hash of an `Expr`: `blake3(put_expr expr)`. Per
-  -- docs/Ixon.md:970-971 — Reveal claim's `Option<Address>` Expr
-  -- fields bind to this hash.
-  -- ============================================================================
+  -- Content hash of an `Expr`: `blake3(put_expr expr)`.
   fn expr_addr(e_ref: &Expr) -> Addr {
     let bytes = put_expr(load(e_ref), store(ListNode.Nil));
     bytes_to_addr(bytes)
   }
 
-  -- ============================================================================
   -- Per-field equality checks. None = no-op (selective reveal);
   -- Some(claimed) = assert equality with the real field.
-  -- ============================================================================
   fn def_kind_tag(k: DefKind) -> G {
     match k {
       DefKind.Definition => 0,
@@ -489,7 +848,8 @@ def claim := ⟦
     match opt {
       Option.None => (),
       Option.Some(claimed) =>
-        assert_eq!(def_kind_tag(real), def_kind_tag(claimed));
+        assert_eq!(def_kind_tag(real), def_kind_tag(claimed),
+          "Reveal: claimed definition kind != real");
         (),
     }
   }
@@ -499,7 +859,8 @@ def claim := ⟦
     match opt {
       Option.None => (),
       Option.Some(claimed) =>
-        assert_eq!(def_safety_tag(real), def_safety_tag(claimed));
+        assert_eq!(def_safety_tag(real), def_safety_tag(claimed),
+          "Reveal: claimed definition safety != real");
         (),
     }
   }
@@ -508,7 +869,8 @@ def claim := ⟦
     match opt {
       Option.None => (),
       Option.Some(claimed) =>
-        assert_eq!(quot_kind_tag(real), quot_kind_tag(claimed));
+        assert_eq!(quot_kind_tag(real), quot_kind_tag(claimed),
+          "Reveal: claimed quotient kind != real");
         (),
     }
   }
@@ -517,7 +879,7 @@ def claim := ⟦
     match opt {
       Option.None => (),
       Option.Some(claimed) =>
-        assert_eq!(real, claimed);
+        assert_eq!(real, claimed, "Reveal: claimed flag != real");
         (),
     }
   }
@@ -526,7 +888,7 @@ def claim := ⟦
     match opt {
       Option.None => (),
       Option.Some(claimed) =>
-        assert_eq!(real, claimed);
+        assert_eq!(real, claimed, "Reveal: claimed numeric field != real");
         (),
     }
   }
@@ -535,7 +897,8 @@ def claim := ⟦
     match opt {
       Option.None => (),
       Option.Some(claimed) =>
-        assert_eq!(load(real), load(claimed));
+        assert_eq!(load(real), load(claimed),
+          "Reveal: claimed address field != real");
         (),
     }
   }
@@ -545,16 +908,24 @@ def claim := ⟦
       Option.None => (),
       Option.Some(claimed) =>
         let computed = expr_addr(real_e);
-        assert_eq!(load(computed), load(claimed));
+        assert_eq!(load(computed), load(claimed),
+          "Reveal: claimed expr hash != hash of the real expr");
         (),
     }
   }
 
   -- Walk both lists in lockstep: claimed (idx, fields, rhs_addr) per
-  -- entry vs real (fields, rhs:&Expr) — positional `idx` is read but
-  -- not asserted (matches `Ix.RevealRecursorRule.ruleIdx` semantics).
+  -- entry vs real (fields, rhs:&Expr).
+  --
+  -- The claimed `idx` is part of the reveal's digest, so a consumer reads it
+  -- and believes it identifies WHICH rule was revealed. The comparison here
+  -- is positional, so without this assert a reveal could carry
+  -- `ruleIdx: 7` while matching the rule at position 0 — the consumer then
+  -- believes it learned rule 7 and it learned rule 0. Every sibling reveal
+  -- check (CPrj/RPrj/IPrj/DPrj) already validates its index.
   fn check_recr_rules(real: List‹RecursorRule›,
-                      claimed: List‹RevealRecursorRule›) {
+                      claimed: List‹RevealRecursorRule›,
+                      pos: U64) {
     match load(claimed) {
       ListNode.Nil =>
         match load(real) {
@@ -564,12 +935,16 @@ def claim := ⟦
         match load(real) {
           ListNode.Cons(rr, rest_real) =>
             match cr {
-              RevealRecursorRule.Mk(_c_idx, c_fields, c_rhs) =>
+              RevealRecursorRule.Mk(c_idx, c_fields, c_rhs) =>
                 match rr {
                   RecursorRule.Mk(r_fields, r_rhs) =>
-                    assert_eq!(r_fields, c_fields);
+                    assert_eq!(c_idx, pos,
+                      "Reveal: claimed recursor rule index != its position");
+                    assert_eq!(r_fields, c_fields,
+                      "Reveal: claimed recursor rule field count != real");
                     check_opt_expr_addr(r_rhs, Option.Some(c_rhs));
-                    check_recr_rules(rest_real, rest_claimed),
+                    check_recr_rules(rest_real, rest_claimed,
+                      relaxed_u64_succ(pos)),
                 },
             },
         },
@@ -580,7 +955,9 @@ def claim := ⟦
                           opt: Option‹List‹RevealRecursorRule››) {
     match opt {
       Option.None => (),
-      Option.Some(claimed) => check_recr_rules(real, claimed),
+      Option.Some(claimed) =>
+        check_recr_rules(real, claimed,
+          [0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]),
     }
   }
 
@@ -695,176 +1072,6 @@ def claim := ⟦
     }
   }
 
-  -- ============================================================================
-  -- Merkle leaf / node hash (Ix.Merkle.leafHash / nodeHash).
-  -- ============================================================================
-  fn leaf_hash(addr: Addr) -> Addr {
-    let tail = put_address(addr, store(ListNode.Nil));
-    let bytes = store(ListNode.Cons(0u8, tail));
-    bytes_to_addr(bytes)
-  }
-
-  fn node_hash(l: Addr, r: Addr) -> Addr {
-    let tail = put_address(l, put_address(r, store(ListNode.Nil)));
-    let bytes = store(ListNode.Cons(1u8, tail));
-    bytes_to_addr(bytes)
-  }
-
-  -- ============================================================================
-  -- Assumption-tree parser / loader. Same as constants: load bytes,
-  -- recompute root via merkle fold, assert match.
-  -- ============================================================================
-  fn parse_atree_body(stream: ByteStream) -> (Addr, List‹Addr›, ByteStream) {
-    let (tag, s) = read_byte(stream);
-    match tag {
-      0 =>
-        let (addr, s2) = get_address(s);
-        let h = leaf_hash(addr);
-        (h, store(ListNode.Cons(addr, store(ListNode.Nil))), s2),
-      1 =>
-        (store([0u8; 32]), store(ListNode.Nil), s),
-      2 =>
-        let (lh, ll, s2) = parse_atree_body(s);
-        let (rh, rl, s3) = parse_atree_body(s2);
-        let h = node_hash(lh, rh);
-        (h, list_concat(ll, rl), s3),
-    }
-  }
-
-  fn load_assumption_tree(root: Addr) -> List‹Addr› {
-    let raw = load(root);
-    let (idx, len) = io_get_info(1, raw);
-    let bytes = #read_byte_stream(1, idx, len);
-    let (tag, s) = get_tag4(bytes);
-    let (flag, size) = tag;
-    assert_eq!(flag, 0xE);
-    assert_eq!(to_field(size[0]), 2);
-    let (computed_root, leaves, rest) = parse_atree_body(s);
-    assert_eq!(load(rest), ListNode.Nil);
-    let computed_arr = load(computed_root);
-    assert_eq!(computed_arr, raw);
-    leaves
-  }
-
-  fn addr_in_list(target: Addr, xs: List‹Addr›) -> G {
-    match load(xs) {
-      ListNode.Nil => 0,
-      ListNode.Cons(a, rest) =>
-        match address_eq(target, a) {
-          1 => 1,
-          _ => addr_in_list(target, rest),
-        },
-    }
-  }
-
-  -- Pack the first 4 address bytes (LE) into a u32 key for addr-keyed
-  -- rbtrees (block-membership table in `Inductive.lean`).
-  --
-  -- Capped at 4 bytes because `RBTreeMap` orders keys with `u32_less_than`, a
-  -- 32-bit comparator gadget — a wider key (a single `G` could hold 7 bytes in
-  -- Goldilocks) would overflow it and corrupt the tree ordering. A 32-bit key
-  -- space means key collisions are possible; consumers must be
-  -- collision-tolerant.
-  fn addr_key(a: Addr) -> G {
-    let arr = load(a);
-    to_field(arr[0])
-      + to_field(arr[1]) * 256
-      + to_field(arr[2]) * 65536
-      + to_field(arr[3]) * 16777216
-  }
-
-  -- Membership map over the assumption leaves, keyed by `ptr_val`. Sound
-  -- by the same invariant as `build_addr_pos_map` (Ingress.lean): one
-  -- pointer maps to one content, so a ptr hit implies the address IS a
-  -- leaf (no false skip); a de-interned pointer reads as absent, which
-  -- here only means the constant gets CHECKED instead of skipped —
-  -- conservative. One tree lookup per constant, no confirming
-  -- address_eq, no per-lookup address loads (ported from jcb/fixes
-  -- H-14; replaces the 4-byte-content-keyed set + confirm compare).
-  fn build_asm_leaf_map(leaves: List‹Addr›) -> RBTreeMap‹G› {
-    match load(leaves) {
-      ListNode.Nil => RBTreeMap.Nil,
-      ListNode.Cons(a, rest) =>
-        rbtree_map_insert(ptr_val(a), 1, build_asm_leaf_map(rest)),
-    }
-  }
-
-  -- ============================================================================
-  -- check_all variant that skips positions whose addr is in the
-  -- supplied assumption-leaf list.
-  -- ============================================================================
-  fn check_all_skipping(consts: List‹&KConstantInfo›,
-                        top: List‹&KConstantInfo›,
-                        addrs: List‹Addr›,
-                        asm_leaves: List‹Addr›) {
-    check_canonical_block_sort(top, addrs);
-    -- Build the ptr_val-keyed skip map once (O(N log N)).
-    let asm_map = store(build_asm_leaf_map(asm_leaves));
-    check_all_skipping_iter(consts, top, addrs, addrs, asm_map, 0)
-  }
-
-  -- `cur_addrs` is the suffix of `addrs` aligned with `consts`, walked in
-  -- lockstep instead of `list_lookup(addrs, pos)` — which re-walks the
-  -- list prefix every iteration, a standalone quadratic in closure size
-  -- (ported from jcb/fixes H-14).
-  fn check_all_skipping_iter(consts: List‹&KConstantInfo›,
-                             top: List‹&KConstantInfo›,
-                             addrs: List‹Addr›,
-                             cur_addrs: List‹Addr›,
-                             asm_map: &RBTreeMap‹G›,
-                             pos: G) {
-    match load(consts) {
-      ListNode.Nil => (),
-      ListNode.Cons(&ci, rest) =>
-        match load(cur_addrs) {
-          ListNode.Cons(addr, rest_addrs) =>
-            match rbtree_map_lookup_or_default(ptr_val(addr), load(asm_map), 0) {
-              0 =>
-                check_const(ci, pos, top, addrs);
-                check_all_skipping_iter(rest, top, addrs, rest_addrs, asm_map, pos + 1),
-              _ =>
-                check_all_skipping_iter(rest, top, addrs, rest_addrs, asm_map, pos + 1),
-            },
-        },
-    }
-  }
-
-  -- ============================================================================
-  -- Per-variant handlers. Each takes already-parsed claim fields.
-  -- ============================================================================
-  fn run_check(const_addr: Addr, asm: Option‹Addr›) {
-    let (k_consts, addrs) = ingress_with_primitives(const_addr);
-    match asm {
-      Option.None => check_all(k_consts, k_consts, addrs),
-      Option.Some(asm_root) =>
-        let asm_leaves = load_assumption_tree(asm_root);
-        check_all_skipping(k_consts, k_consts, addrs, asm_leaves),
-    }
-  }
-
-  fn run_contains(tree_root: Addr, target_addr: Addr) {
-    let leaves = load_assumption_tree(tree_root);
-    assert_eq!(addr_in_list(target_addr, leaves), 1);
-  }
-
-  -- Ingress the union closure of all env leaves ONCE, then check every
-  -- constant in it (skipping assumption leaves) via the same
-  -- `check_all_skipping` path `run_check` uses. Structurally a
-  -- `run_check` over a closure that happens to be the whole env, so the
-  -- soundness rides on that existing pattern; the union order is verified by
-  -- the single `check_canonical_block_sort(top)` inside `check_all_skipping`
-  -- (a stronger global order than the per-leaf closures it replaces).
-  fn run_check_env(env_root: Addr, asm: Option‹Addr›) {
-    let env_leaves = load_assumption_tree(env_root);
-    let (k_consts, addrs) = ingress_env(env_leaves);
-    match asm {
-      Option.None => check_all(k_consts, k_consts, addrs),
-      Option.Some(asm_root) =>
-        let asm_leaves = load_assumption_tree(asm_root);
-        check_all_skipping(k_consts, k_consts, addrs, asm_leaves),
-    }
-  }
-
   -- Reveal: real constant at `comm` must match the variant of `info`
   -- AND every Some-field's claimed value must equal the real field.
   fn run_reveal(comm_addr: Addr, info: RevealConstantInfo) {
@@ -970,47 +1177,71 @@ def claim := ⟦
     }
   }
 
-  fn run_eval(input: Addr, output: Addr, asm: Option‹Addr›) {
-    -- Eval semantics undefined upstream; placeholder until Rust kernel
-    -- pins them.
-    assert_eq!(0, 1);
+  -- Contains claim (variant 7): merkle membership of `target` in the
+  -- tree at `tree_root`. Mirror run_contains.
+  fn run_contains(tree_root: Addr, target: Addr) {
+    let leaves = load_assumption_tree(tree_root);
+    assert_eq!(se_addr_in(target, leaves), 1,
+      "Contains: target is not a leaf of the claimed tree");
   }
 
-  -- ============================================================================
-  -- Top-level entrypoint.
-  -- ============================================================================
-  --
-  -- Public input: 32-G blake3 digest of `Claim.ser claim`. Flow
-  -- mirrors `load_verified_constant`: hash-verified bytes deserialize
-  -- into a typed `Claim`, then dispatch.
-  pub fn verify_claim(claim_digest: [U8; 32]) {
-    let claim = load_verified_claim(claim_digest);
-    match claim {
-      Claim.Eval(input, output, asm) => run_eval(input, output, asm),
-      Claim.Check(c, asm) => run_check(c, asm),
-      Claim.CheckEnv(root, asm) => run_check_env(root, asm),
-      Claim.Reveal(comm, info) => run_reveal(comm, info),
-      Claim.Contains(tree, target) => run_contains(tree, target),
+  -- Claim dispatch. Loads claim bytes at ch 0 keyed by digest,
+  -- blake3-verifies, and dispatches:
+  --   variant 4 (Check target asm?)  → transitive check; with asm the
+  --     walk stops at frontier members (no owned-membership rule —
+  --     Check claims target + everything reachable, no ownership set).
+  --   variant 5 (CheckEnv root asm?) → run_check_env: per-leaf
+  --     transitive walk, asm cutoff, strict owned-membership.
+  --   variant 6 (Reveal comm info)   → run_reveal: selective field
+  --     revelation of the committed constant.
+  --   variant 7 (Contains tree target) → run_contains: merkle
+  --     membership.
+  -- Variants without an arm here (notably 3, Eval) have no defined
+  -- semantics upstream, so the match falls through and aborts rather
+  -- than accepting a claim whose meaning is unspecified.
+  fn run_claim(digest: [U8; 32]) {
+    let (idx, len) = io_get_info(0, digest);
+    let bytes = #read_byte_stream(0, idx, len);
+    verify_bytes_against(bytes, digest);
+    let (tag, s) = get_tag4(bytes);
+    let (flag, size) = tag;
+    assert_eq!(flag, 0xE, "claim: wrong tag4 flag");
+    -- Dispatch on the FULL tag4 size, matching Rust `Claim::get` which
+    -- matches `tag.size: u64`. The variant is only ever 4-7, so the high 7
+    -- bytes must be zero; a size >= 256 whose low byte is 4/5/6/7 would
+    -- otherwise dispatch here while Rust rejects it as an unknown variant.
+    -- Sum is 0 iff every high byte is 0 (7 bytes, max sum 1785, no wrap).
+    let [_, sz1, sz2, sz3, sz4, sz5, sz6, sz7] = size;
+    assert_eq!(((((((to_field(sz1) + to_field(sz2)) + to_field(sz3))
+                  + to_field(sz4)) + to_field(sz5)) + to_field(sz6))
+                  + to_field(sz7)), 0,
+      "claim: tag4 size exceeds a single byte");
+    let variant = size[0];
+    match variant {
+      4 =>
+        let (target, s2) = get_address(s);
+        let (asm, _s3) = get_opt_addr(s2);
+        match asm {
+          Option.None => run_check_transitive(target),
+          Option.Some(r) =>
+            let asm_leaves = load_assumption_tree(r);
+            let asm_set = addr_set_build(asm_leaves, RBTreeMap.Nil);
+            env_walk(target, RBTreeMap.Nil, asm_set, 0),
+        },
+      5 =>
+        let (root, s2) = get_address(s);
+        let (asm, _s3) = get_opt_addr(s2);
+        run_check_env(root, asm),
+      6 =>
+        let (comm, s2) = get_address(s);
+        let (info, _s3) = get_reveal_info(s2);
+        run_reveal(comm, info),
+      7 =>
+        let (tree, s2) = get_address(s);
+        let (target, _s3) = get_address(s2);
+        run_contains(tree, target),
     }
   }
-
-  -- ============================================================================
-  -- verify_const: subject-only typecheck entrypoint. Checks the
-  -- constant at `target_addr` in isolation; transitive deps are
-  -- trusted (not re-verified). NOT a claim path — the public
-  -- `verify_claim` is the only entrypoint that goes through the
-  -- claim-digest discipline. Used by the in-Lean arena test runner
-  -- (`Tests/Ix/Kernel/Arena.lean::arenaTests`) where each fixture
-  -- is a self-contained decl whose own well-typedness is the only
-  -- thing the test cares about.
-  -- ============================================================================
-  pub fn verify_const(target_addr: [U8; 32]) {
-    let target = store(target_addr);
-    let (k_consts, addrs) = ingress_with_primitives(target);
-    let target_pos = find_addr_idx(target, addrs, 0);
-    let ci = load(list_lookup(k_consts, target_pos));
-    check_const(ci, target_pos, k_consts, addrs)
-  }
 ⟧
 
 end IxVM
diff --git a/Ix/IxVM/Kernel/DefEq.lean b/Ix/IxVM/Kernel/DefEq.lean
index 2325652c0..58578cd90 100644
--- a/Ix/IxVM/Kernel/DefEq.lean
+++ b/Ix/IxVM/Kernel/DefEq.lean
@@ -2,245 +2,117 @@ 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
 
 namespace IxVM
 
-/-! ## Definitional equality over `KExpr`
-
-Mirrors `src/ix/kernel/def_eq.rs`.
-
-Tiered strategy:
-
-1. **Structural alpha-equivalence**: same expression shapes with recursive
-   def_eq on sub-expressions. Pointer equality short-circuit.
-2. **WHNF**: reduce both sides; retry structural.
-3. **Proof irrelevance**: both sides accepted when their inferred type is
-   a Prop. Implemented via `is_prop_type_of` over the shared types ctx.
-4. **Lazy delta**: simultaneous unfold of both sides when both heads are
-   Const(idx) of a Defn/Thm; falls through to Const-Proj / Proj-Const /
-   Const-App congruence when applicable.
-5. **Lambda eta**: when one side is a `Lam` and the other isn't, wrap the
-   non-Lam side as `λ(dom). s #0` (via `expr_lift`) and recurse via the
-   structural Lam-Lam arm.
-6. **Struct / unit-like eta**: subsingleton Prop ctors and recursive
-   single-ctor structures fold via `is_unit_like_type` and the iota
-   step in `Whnf.lean::try_struct_eta_iota`.
--/
+/-! ## Def-Eq
 
-def defEq := ⟦
-  -- ============================================================================
-  -- k_is_def_eq
-  --
-  -- Mirror of `src/ix/kernel/def_eq.rs::is_def_eq`. Returns G:
-  -- 1 = def-eq, 0 = not.
-  -- ============================================================================
-  fn k_is_def_eq(a: KExpr, b: KExpr, types: List‹KExpr›,
-                 top: List‹&KConstantInfo›, addrs: List‹Addr›) -> G {
-    -- Tier 1: pointer equality short-circuit.
-    match ptr_val(a) - ptr_val(b) {
-      0 => 1,
-      -- Context-trimmed memo key (mirror Rust `def_eq_ctx_key`): decide on the
-      -- suffix of `types` reachable from either side; closed pairs (lbr 0) key
-      -- to the empty context and share across binder depths.
-      _ => k_is_def_eq_core(a, b, ctx_trim(types, lbr_max(expr_lbr(a), expr_lbr(b))), top, addrs),
-    }
-  }
-
-  -- Def-eq is symmetric (every tier below treats the sides symmetrically or
-  -- tries both directions), so canonicalize the pair by pointer order before
-  -- the tiered run: (a, b) and (b, a) share one ordered run, and — the
-  -- larger effect — the eta/structural recursion below issues its
-  -- `expr_inst1`/`expr_lift` traffic with a canonical orientation, deduping
-  -- instantiation work across mirrored queries. Sorting lives here rather
-  -- than in `k_is_def_eq`: this circuit runs once per unique pair, the entry
-  -- once per call, and the swap costs a second call-site's width. Pointer
-  -- values fit u32 for any feasible trace.
-  fn k_is_def_eq_core(a: KExpr, b: KExpr, types: List‹KExpr›,
-                      top: List‹&KConstantInfo›, addrs: List‹Addr›) -> G {
-    match u32_less_than(ptr_val(a), ptr_val(b)) {
-      1 => k_is_def_eq_ordered(a, b, types, top, addrs),
-      0 => k_is_def_eq_ordered(b, a, types, top, addrs),
-    }
-  }
+`k_is_def_eq(a, b, types) → 1 iff a ≡ b`. Decided by a ladder of tiers,
+cheapest first, because the expensive tiers are the ones that unfold
+definitions and can blow up:
 
-  fn k_is_def_eq_ordered(a: KExpr, b: KExpr, types: List‹KExpr›,
-                         top: List‹&KConstantInfo›, addrs: List‹Addr›) -> G {
-        -- Tier 1.5: lazy-delta app-congruence pre-WHNF. Mirror:
-        -- src/ix/kernel/def_eq.rs:1262-1287 try_def_eq_app. When both
-        -- sides share Const(idx, lvls) head with same arg count, recurse
-        -- on args directly. Sound: only accepts when args recursively def-eq.
-        match try_lazy_delta_app(a, b, types, top, addrs) {
-          1 => 1,
-          0 =>
-        -- Tier 1c: string literal expansion (must run before WHNF). Mirror:
-        -- src/ix/kernel/def_eq.rs:295-304. If exactly one side is Lit(Str),
-        -- expand to `String.ofList [Char.ofNat c, ...]` ctor form so both
-        -- sides reduce in lockstep through delta + iota.
-        match try_string_lit_pair(a, b, types, top, addrs) {
-          1 => 1,
-          0 =>
-            -- Tier 1d: no-delta whnf + structural shortcuts (mirror Rust
-            -- `whnf_no_delta_for_def_eq` + `quick_def_eq` + post-`try_def_eq_app`).
-            let aw_nd = whnf_nd(a, types, top, addrs);
-            let bw_nd = whnf_nd(b, types, top, addrs);
-            match ptr_val(aw_nd) - ptr_val(bw_nd) {
-              0 => 1,
-              _ =>
-                match k_is_def_eq_struct_safe(aw_nd, bw_nd, types, top, addrs) {
-                  1 => 1,
-                  0 =>
-                    match try_lazy_delta_app(aw_nd, bw_nd, types, top, addrs) {
-                      1 => 1,
-                      0 =>
-            -- Tier 2: WHNF both sides.
-            let aw = whnf(a, types, top, addrs);
-            let bw = whnf(b, types, top, addrs);
-            match ptr_val(aw) - ptr_val(bw) {
-              0 => 1,
-              _ =>
-                -- Tier 3: proof irrelevance.
-                match try_proof_irrel(aw, bw, types, top, addrs) {
-                  1 => 1,
-                  0 =>
-                    -- Tier 3b: unit-like-type symmetry.
-                    match try_unit_like(aw, bw, types, top, addrs) {
-                      1 => 1,
-                      0 =>
-                        -- Tier 3c: struct eta (mirror def_eq.rs:778-784).
-                        match try_eta_struct(aw, bw, types, top, addrs) {
-                          1 => 1,
-                          0 =>
-                            match try_eta_struct(bw, aw, types, top, addrs) {
-                              1 => 1,
-                              0 =>
-                                -- Tier 3d: Nat offset (mirror def_eq.rs:751).
-                                match try_def_eq_nat(aw, bw, types, top, addrs) {
-                                  (1, eq) => eq,
-                                  (0, _) =>
-                                    -- Tier 4: lazy-delta unfold loop (mirror
-                                    -- def_eq.rs:1418-1483 lazy_delta_reduction_step).
-                                    -- Both sides may be Const-headed Defn/Thm
-                                    -- left stuck by whnf (Opaque hint or Theorem).
-                                    -- Unfold one side per rank; recurse.
-                                    match lazy_delta_loop(aw, bw, 16, types, top, addrs) {
-                                      (1, eq) => eq,
-                                      (0, _) => k_is_def_eq_struct(aw, bw, types, top, addrs),
-                                    },
-                                },
-                            },
-                        },
-                    },
-                },
-            },
-                    },
-                },
-            },
-        },
-        }
-  }
+pointer equality → memo lookup on a context-trimmed, pointer-ordered key
+→ app congruence on a shared Const head (no unfolding) → string-literal
+expansion → no-delta whnf (`whnf_nd`) plus `quick_def_eq` → proof
+irrelevance → unit-like types → structure eta → Nat offset comparison →
+lazy delta, unfolding the higher-ranked side first → full structural
+compare.
+
+Tier order is load-bearing rather than a matter of taste; where a tier's
+position matters for correctness and not just cost, the reason is
+recorded at that tier.
+-/
 
-  -- Mirror Rust `def_eq.rs::quick_def_eq`. Sound on partially-whnf'd
-  -- (no-delta) inputs because the handled shapes (Sort/Lam/All) don't
-  -- depend on further reductions for their judgment. Returns 1 only
-  -- when DEFINITELY def-eq; 0 = fall through.
-  fn k_is_def_eq_struct_safe(a: KExpr, b: KExpr, types: List‹KExpr›,
-                              top: List‹&KConstantInfo›, addrs: List‹Addr›) -> G {
+def defEq := ⟦
+  -- Level list equality (semantic, uses level normalization).
+  fn level_list_eq(a: List‹KLevel›, b: List‹KLevel›) -> G {
     match load(a) {
-      KExprNode.Srt(la) =>
-        match load(b) {
-          KExprNode.Srt(lb) => level_equal(la, lb),
-          _ => 0,
-        },
-      KExprNode.Lam(ty_a, body_a) =>
+      ListNode.Nil =>
         match load(b) {
-          KExprNode.Lam(ty_b, body_b) =>
-            match k_is_def_eq(ty_a, ty_b, types, top, addrs) {
-              1 =>
-                let inner = store(ListNode.Cons(ty_a, types));
-                k_is_def_eq(body_a, body_b, inner, top, addrs),
-              0 => 0,
-            },
+          ListNode.Nil => 1,
           _ => 0,
         },
-      KExprNode.Forall(ty_a, body_a) =>
+      ListNode.Cons(x, xs) =>
         match load(b) {
-          KExprNode.Forall(ty_b, body_b) =>
-            match k_is_def_eq(ty_a, ty_b, types, top, addrs) {
-              1 =>
-                let inner = store(ListNode.Cons(ty_a, types));
-                k_is_def_eq(body_a, body_b, inner, top, addrs),
+          ListNode.Nil => 0,
+          ListNode.Cons(y, ys) =>
+            match level_equal(x, y) {
               0 => 0,
+              _ => level_list_eq(xs, ys),
             },
-          _ => 0,
         },
-      _ => 0,
     }
   }
 
-  -- Mirror: src/ix/kernel/def_eq.rs:801-818 fn try_proof_irrel.
-  fn try_proof_irrel(a: KExpr, b: KExpr, types: List‹KExpr›,
-                     top: List‹&KConstantInfo›, addrs: List‹Addr›) -> G {
-    let a_ty = k_infer_only(a, types, top, addrs);
-    match is_prop_type(a_ty, types, top, addrs) {
-      0 => 0,
-      1 =>
-        let b_ty = k_infer_only(b, types, top, addrs);
-        k_is_def_eq(a_ty, b_ty, types, top, addrs),
+  -- Main entry: def-eq of two KExpr in a shared types context.
+  -- Context-trimmed memo key (mirror k_is_def_eq / Rust
+  -- def_eq_ctx_key): key on the suffix of `types` reachable from
+  -- either side; closed pairs (lbr 0) key to the empty context and
+  -- share across binder depths. Without the trim, the same pair
+  -- compared under every distinct binder context memoizes separately —
+  -- on deep dependent proof towers that is an exponential duplicate-
+  -- work (and QueryRecord memory) amplifier.
+  fn k_is_def_eq(a: KExpr, b: KExpr, types: List‹KExpr›) -> G {
+    match ptr_val(a) - ptr_val(b) {
+      0 => 1,  -- ptr-eq: same interned pointer = equal
+      _ => k_is_def_eq_core(a, b,
+             ctx_trim(types, lbr_max(expr_lbr(a), expr_lbr(b)))),
     }
   }
 
-  -- Returns 1 iff `whnf(infer(ty))` is `Sort 0`.
-  fn is_prop_type(ty: KExpr, types: List‹KExpr›,
-                  top: List‹&KConstantInfo›, addrs: List‹Addr›) -> G {
-    let sort = k_infer_only(ty, types, top, addrs);
-    let sort_w = whnf(sort, types, top, addrs);
-    match load(sort_w) {
-      KExprNode.Srt(l) =>
-        match load(l) {
-          KLevelNode.Zero => 1,
-          _ => 0,
-        },
-      _ => 0,
+  -- Def-eq is symmetric (every tier treats the sides symmetrically or
+  -- tries both directions), so canonicalize the pair by pointer order
+  -- (mirror k_is_def_eq_core): (a, b) and (b, a) share one ordered
+  -- memo row, and the recursion below issues instantiation traffic
+  -- with a canonical orientation.
+  fn k_is_def_eq_core(a: KExpr, b: KExpr, types: List‹KExpr›) -> G {
+    match u32_less_than(ptr_val(a), ptr_val(b)) {
+      1 => k_is_def_eq_ordered(a, b, types),
+      _ => k_is_def_eq_ordered(b, a, types),
     }
   }
 
-  -- Mirror: src/ix/kernel/def_eq.rs:858-905 fn try_unit_like_eq.
-  fn try_unit_like(a: KExpr, b: KExpr, types: List‹KExpr›,
-                   top: List‹&KConstantInfo›, addrs: List‹Addr›) -> G {
-    let ta = k_infer_only(a, types, top, addrs);
-    let ta_w = whnf(ta, types, top, addrs);
-    match is_unit_like_type(ta_w, top) {
-      0 => 0,
-      1 =>
-        let tb = k_infer_only(b, types, top, addrs);
-        k_is_def_eq(ta, tb, types, top, addrs),
+  fn k_is_def_eq_ordered(a: KExpr, b: KExpr, types: List‹KExpr›) -> G {
+    -- Pre-WHNF lazy-delta app congruence.
+    -- When both sides share Const head + same lvl args + arity,
+    -- recurse on arg lists without unfolding — avoids expensive
+    -- delta on cases where args recursively def-eq.
+    match try_def_eq_app(a, b, types) {
+      1 => 1,
+      _ => k_is_def_eq_slow(a, b, types),
     }
   }
 
-  -- 1 iff ty is `Const(I, _) args` for a 1-ctor 0-field inductive.
-  -- (A 0-field ctor cannot reference the block, so an is_rec check would
-  -- be redundant — mirror def_eq.rs try_unit_like, which dropped the flag
-  -- when Ixon stopped storing it.)
-  fn is_unit_like_type(ty: KExpr, top: List‹&KConstantInfo›) -> G {
-    match collect_spine(ty) {
-      (head, _) =>
-        match load(head) {
-          KExprNode.Const(idx, _) =>
-            let ci = load(list_lookup(top, idx));
-            match ci {
-              KConstantInfo.Induct(_, _, _, _, ctor_indices, _, _) =>
-                match list_length(ctor_indices) {
-                  1 =>
-                    let ctor_idx = list_lookup(ctor_indices, 0);
-                    let ctor_ci = load(list_lookup(top, ctor_idx));
-                    match ctor_ci {
-                      KConstantInfo.Ctor(_, _, _, _, _, n_fields, _) =>
-                        match n_fields {
-                          0 => 1,
-                          _ => 0,
+  -- App-congruence PRE-WHNF: if both sides collect_spine to
+  -- (Const(addr), args) with same addr + same level args + same arity,
+  -- recurse on args pairwise. Sound: if all args def-eq, whole exprs
+  -- def-eq without unfolding the const.
+  fn try_def_eq_app(a: KExpr, b: KExpr, types: List‹KExpr›) -> G {
+    match collect_spine(a) {
+      (ah, aa) =>
+        match collect_spine(b) {
+          (bh, bb) =>
+            match load(ah) {
+              KExprNode.Const(a_addr, al) =>
+                match load(bh) {
+                  KExprNode.Const(b_addr, bl) =>
+                    match ptr_val(a_addr) - ptr_val(b_addr) {
+                      0 =>
+                        match level_list_eq(al, bl) {
+                          0 => 0,
+                          _ =>
+                            match list_length(aa) - list_length(bb) {
+                              0 => de_args(aa, bb, types),
+                              _ => 0,
+                            },
                         },
                       _ => 0,
                     },
@@ -248,69 +120,48 @@ def defEq := ⟦
                 },
               _ => 0,
             },
-          _ => 0,
         },
     }
   }
 
-  -- Mirror: src/ix/kernel/def_eq.rs:1007-1018 try_string_lit_expansion,
-  -- attempted in both directions.
-  fn try_string_lit_pair(a: KExpr, b: KExpr, types: List‹KExpr›,
-                         top: List‹&KConstantInfo›, addrs: List‹Addr›) -> G {
-    match try_string_lit_one(a, b, types, top, addrs) {
-      1 => 1,
-      0 => try_string_lit_one(b, a, types, top, addrs),
-    }
-  }
-
-  fn try_string_lit_one(t: KExpr, s: KExpr, types: List‹KExpr›,
-                        top: List‹&KConstantInfo›, addrs: List‹Addr›) -> G {
-    match load(t) {
-      KExprNode.Lit(lit) =>
-        match lit {
-          KLiteral.Str(bs) =>
-            match str_lit_to_ctor(bs, addrs) {
-              -- One delta step past a Defn `String.ofList` head (mirror
-              -- Rust str_lit_to_ctor_app): the native ofList collapse
-              -- would otherwise fold the expansion straight back into
-              -- the literal and the comparison would never reach the
-              -- structural constructor form.
-              (1, expanded) =>
-                k_is_def_eq(str_lit_delta_step(expanded, types, top, addrs),
-                            s, types, top, addrs),
-              (0, _) => 0,
-            },
+  fn de_args(aa: List‹KExpr›, bb: List‹KExpr›, types: List‹KExpr›) -> G {
+    match load(aa) {
+      ListNode.Nil =>
+        match load(bb) {
+          ListNode.Nil => 1,
           _ => 0,
         },
-      _ => 0,
+      ListNode.Cons(a, ar) =>
+        match load(bb) {
+          ListNode.Nil => 0,
+          ListNode.Cons(b, br) =>
+            match k_is_def_eq(a, b, types) {
+              0 => 0,
+              _ => de_args(ar, br, types),
+            },
+        },
     }
   }
 
-  -- Mirror: src/ix/kernel/def_eq.rs:920-926 fn is_nat_zero.
-  fn is_nat_zero(e: KExpr, addrs: List‹Addr›) -> G {
+  -- Nat.zero recognition for offset-aware def_eq.
+  fn is_nat_zero(e: KExpr) -> G {
     match load(e) {
       KExprNode.Lit(lit) =>
         match lit {
           KLiteral.Nat(limbs) => klimbs_is_zero(limbs),
           _ => 0,
         },
-      KExprNode.Const(idx, _) =>
-        address_eq(list_lookup(addrs, idx), nat_zero_addr()),
+      KExprNode.Const(caddr, _) => address_eq(caddr, nat_zero_addr()),
       _ => 0,
     }
   }
 
-
-  -- Decompose a WHNF'd Nat into `base + offset` where `base` is the
-  -- non-offset core and `offset` a KLimbs literal. Recognizes:
-  --   Lit n               -> (matched, 0-base, n)
-  --   Nat.succ e          -> base/offset of e, offset+1
-  --   Nat.add e (Lit m)   -> base/offset of e, offset+m
-  -- `matched=1` iff `e` is offset-shaped (succ/add/lit). The few succ layers
-  -- whnf exposes are peeled, but `Nat.add base (Lit m)` is read in O(1) — so a
-  -- `succ^k(x)` chain (which whnf leaves as `succ(Nat.add x (Lit k-1))`)
-  -- decomposes to `(x, k)` in O(1) instead of k unary steps.
-  fn nat_offset_of(e: KExpr, addrs: List‹Addr›) -> (G, KExpr, KLimbs) {
+  -- Decompose a whnf'd Nat into (matched, base, offset). Recognizes:
+  --   Lit n              -> (1, Lit 0, n)
+  --   Nat.succ e         -> base/offset of e, offset+1
+  --   Nat.add e (Lit m)  -> base/offset of e, offset+m
+  -- Mirror nat_offset_of.
+  fn nat_offset_of(e: KExpr) -> (G, KExpr, KLimbs) {
     match load(e) {
       KExprNode.Lit(lit) =>
         match lit {
@@ -319,32 +170,32 @@ def defEq := ⟦
         },
       KExprNode.App(f, a) =>
         match load(f) {
-          KExprNode.Const(idx, _) =>
-            match address_eq(list_lookup(addrs, idx), nat_succ_addr()) {
+          KExprNode.Const(caddr, _) =>
+            match address_eq(caddr, nat_succ_addr()) {
               1 =>
-                match nat_offset_of(a, addrs) {
+                match nat_offset_of(a) {
                   (_, base, o) => (1, base, klimbs_succ(o)),
                 },
-              0 => (0, e, store(ListNode.Nil)),
+              _ => (0, e, store(ListNode.Nil)),
             },
           KExprNode.App(g, x) =>
             match load(g) {
-              KExprNode.Const(idx, _) =>
-                match address_eq(list_lookup(addrs, idx), nat_add_addr()) {
+              KExprNode.Const(caddr, _) =>
+                match address_eq(caddr, nat_add_addr()) {
                   1 =>
                     match load(a) {
                       KExprNode.Lit(alit) =>
                         match alit {
                           KLiteral.Nat(m) =>
-                            match nat_offset_of(x, addrs) {
+                            match nat_offset_of(x) {
                               (1, base, o) => (1, base, klimbs_add(o, m)),
-                              (0, _, _) => (1, x, m),
+                              _ => (1, x, m),
                             },
                           _ => (0, e, store(ListNode.Nil)),
                         },
                       _ => (0, e, store(ListNode.Nil)),
                     },
-                  0 => (0, e, store(ListNode.Nil)),
+                  _ => (0, e, store(ListNode.Nil)),
                 },
               _ => (0, e, store(ListNode.Nil)),
             },
@@ -354,30 +205,163 @@ def defEq := ⟦
     }
   }
 
-  -- Mirror: src/ix/kernel/def_eq.rs:953-995 is_def_eq_nat / try_def_eq_offset,
-  -- generalized to offset form. Returns (matched, eq). Conservative: only
-  -- decides when both sides are offset-shaped with EQUAL offsets (then the
-  -- verdict is `base_a ≟ base_b`, sound because `+k` is injective); differing
-  -- offsets or non-offset shapes fall back (matched=0) to the generic path.
-  -- Collapses `succ^k(x) ≟ succ^k(x)` from k unary steps to one klimbs compare.
-  fn try_def_eq_nat(a: KExpr, b: KExpr, types: List‹KExpr›,
-                     top: List‹&KConstantInfo›,
-                     addrs: List‹Addr›) -> (G, G) {
-    let za = is_nat_zero(a, addrs);
-    let zb = is_nat_zero(b, addrs);
+  -- Offset-aware Nat def_eq. Returns (matched, eq). Sound because
+  -- `+k` is injective — equal offsets reduces the compare to base ≟ base.
+  -- Collapses `succ^k(x) ≟ succ^k(x)` from O(k) unary steps to O(1).
+  fn try_def_eq_nat(a: KExpr, b: KExpr, types: List‹KExpr›) -> (G, G) {
+    let za = is_nat_zero(a);
+    let zb = is_nat_zero(b);
     match za * zb {
       1 => (1, 1),
-      0 =>
-        match nat_offset_of(a, addrs) {
+      _ =>
+        match nat_offset_of(a) {
           (ma, ba, oa) =>
-            match nat_offset_of(b, addrs) {
+            match nat_offset_of(b) {
               (mb, bb, ob) =>
                 match ma * mb {
                   0 => (0, 0),
                   _ =>
                     match klimbs_eq(oa, ob) {
                       0 => (0, 0),
-                      1 => (1, k_is_def_eq(ba, bb, types, top, addrs)),
+                      _ => (1, k_is_def_eq(ba, bb, types)),
+                    },
+                },
+            },
+        },
+    }
+  }
+
+  -- Slow path: whnf both sides, structural compare, then proof-irrel
+  -- fallback. On both structural + proof-irrel misses, delta-unfold on
+  -- mismatched Const heads is done inside k_is_def_eq_struct via
+  -- try_lazy_delta_app.
+  -- Tier 1d (mirror DefEq.lean:85-97 / Rust quick_def_eq +
+  -- whnf_no_delta_for_def_eq): no-delta whnf both sides; many pairs
+  -- settle by ptr-eq, safe structural compare, or app-congruence on
+  -- the nd forms — without ever full-delta-unfolding large Defn
+  -- bodies. Only on fall-through do we pay Tier 2's full whnf.
+  -- Tier 1c (mirror DefEq.lean:78-84 / Rust def_eq.rs:295-304
+  -- try_string_lit_expansion): if exactly one side is Lit(Str), expand
+  -- it to `String.ofList [Char.ofNat c, ...]` ctor form so both sides
+  -- reduce in lockstep through delta + iota instead of the literal
+  -- staying opaque while the other side delta-cascades.
+  fn try_string_lit_pair(a: KExpr, b: KExpr, types: List‹KExpr›) -> G {
+    match try_string_lit_one(a, b, types) {
+      1 => 1,
+      _ => try_string_lit_one(b, a, types),
+    }
+  }
+
+  fn try_string_lit_one(t: KExpr, s: KExpr, types: List‹KExpr›) -> G {
+    match load(t) {
+      KExprNode.Lit(lit) =>
+        match lit {
+          KLiteral.Str(bs) =>
+            k_is_def_eq(str_lit_delta_step(str_lit_to_ctor(bs), types),
+                           s, types),
+          _ => 0,
+        },
+      _ => 0,
+    }
+  }
+
+  fn k_is_def_eq_slow(a: KExpr, b: KExpr, types: List‹KExpr›) -> G {
+    match try_string_lit_pair(a, b, types) {
+      1 => 1,
+      _ => k_is_def_eq_slow_nd(a, b, types),
+    }
+  }
+
+  fn k_is_def_eq_slow_nd(a: KExpr, b: KExpr, types: List‹KExpr›) -> G {
+    let aw_nd = whnf_nd(a, types);
+    let bw_nd = whnf_nd(b, types);
+    match ptr_val(aw_nd) - ptr_val(bw_nd) {
+      0 => 1,
+      _ =>
+        match k_is_def_eq_struct_safe(aw_nd, bw_nd, types) {
+          1 => 1,
+          _ =>
+            match try_def_eq_app(aw_nd, bw_nd, types) {
+              1 => 1,
+              _ => k_is_def_eq_slow2(a, b, types),
+            },
+        },
+    }
+  }
+
+  -- Mirror of Rust `def_eq.rs::quick_def_eq`.
+  -- Sound on partially-whnf'd (no-delta) inputs because the handled
+  -- shapes (Sort/Lam/Forall) don't depend on further reduction for
+  -- their judgment. Returns 1 only when DEFINITELY def-eq; 0 = fall
+  -- through.
+  fn k_is_def_eq_struct_safe(a: KExpr, b: KExpr, types: List‹KExpr›) -> G {
+    match load(a) {
+      KExprNode.Srt(la) =>
+        match load(b) {
+          KExprNode.Srt(lb) => level_equal(la, lb),
+          _ => 0,
+        },
+      KExprNode.Lam(ty_a, body_a) =>
+        match load(b) {
+          KExprNode.Lam(ty_b, body_b) =>
+            match k_is_def_eq(ty_a, ty_b, types) {
+              1 =>
+                let inner = store(ListNode.Cons(ty_a, types));
+                k_is_def_eq(body_a, body_b, inner),
+              _ => 0,
+            },
+          _ => 0,
+        },
+      KExprNode.Forall(ty_a, body_a) =>
+        match load(b) {
+          KExprNode.Forall(ty_b, body_b) =>
+            match k_is_def_eq(ty_a, ty_b, types) {
+              1 =>
+                let inner = store(ListNode.Cons(ty_a, types));
+                k_is_def_eq(body_a, body_b, inner),
+              _ => 0,
+            },
+          _ => 0,
+        },
+      _ => 0,
+    }
+  }
+
+  -- Tier order is load-bearing: proof_irrel comes BEFORE any
+  -- structural/eta machinery. With Thm heads stuck in whnf, proof-term
+  -- pairs stay high-level (Lam vs Thm-app etc.); eta-expanding a proof
+  -- fabricates over-applied proof terms whose infer_only aborts —
+  -- proof_irrel must get first shot.
+  fn k_is_def_eq_slow2(a: KExpr, b: KExpr, types: List‹KExpr›) -> G {
+    let aw = whnf(a, types);
+    let bw = whnf(b, types);
+    match ptr_val(aw) - ptr_val(bw) {
+      0 => 1,
+      _ =>
+        match try_proof_irrel(aw, bw, types) {
+          1 => 1,
+          _ =>
+            match try_unit_like(aw, bw, types) {
+              1 => 1,
+              _ =>
+                match try_eta_struct(aw, bw, types) {
+                  1 => 1,
+                  _ =>
+                    match try_eta_struct(bw, aw, types) {
+                      1 => 1,
+                      _ =>
+                        match try_def_eq_nat(aw, bw, types) {
+                          (1, eq) => eq,
+                          _ =>
+                        match lazy_delta_loop(aw, bw, 16, types) {
+                          1 => 1,
+                          _ =>
+                        match try_eta_swap(aw, bw, types) {
+                          1 => 1,
+                          _ => k_is_def_eq_struct(aw, bw, types),
+                        },
+                        },
+                        },
                     },
                 },
             },
@@ -385,37 +369,61 @@ def defEq := ⟦
     }
   }
 
-  -- Mirror: src/ix/kernel/def_eq.rs:1105-1231 fn try_eta_struct.
-  -- Direction (t, s): s is the candidate ctor-headed side. Asserts s is
-  -- App-spine of `Const(ctor)` fully applied, induct is struct-like
-  -- (non-rec, 0 indices, 1 ctor), and field-by-field `Proj(induct, i, t)
-  -- ≡ s_args[num_params + i]`.
-  fn try_eta_struct(t: KExpr, s: KExpr, types: List‹KExpr›,
-                    top: List‹&KConstantInfo›, addrs: List‹Addr›) -> G {
+  -- Struct-eta: if `s` is a fully-applied ctor of a single-ctor
+  -- 0-indices inductive (struct-like) and `t` is any expr,
+  -- accept when `Proj(induct, i, t) ≡ s_args[nparams + i]` for every
+  -- field. Mirror crates/kernel/src.
+  fn try_eta_struct(t: KExpr, s: KExpr, types: List‹KExpr›) -> G {
     match collect_spine(s) {
       (s_head, s_args) =>
         match load(s_head) {
-          KExprNode.Const(cidx, _) =>
-            match load(list_lookup(top, cidx)) {
-              KConstantInfo.Ctor(_, _, induct_idx, _, num_params, num_fields, _) =>
-                let arity_diff = list_length(s_args) - (num_params + num_fields);
-                match arity_diff {
+          KExprNode.Const(ctor_addr, _) =>
+            let ci = load(get_ci(ctor_addr));
+            match ci {
+              KConstantInfo.Ctor(_, _, ind_block_addr, ind_idx, _, nparams, nfields, _) =>
+                match list_length(s_args) - (nparams + nfields) {
                   0 =>
-                    match load(list_lookup(top, induct_idx)) {
-                      KConstantInfo.Induct(_, _, _, n_indices, ctor_indices, _, _) =>
-                        -- struct-like: 0 indices, 1 ctor, computed non-rec
-                        -- (recr flag dropped from Ixon; mirror is_struct_like).
-                        let shape_ok = eq_zero(n_indices) *
-                                       eq_zero(list_length(ctor_indices) - 1);
+                    let ind_ci = load(get_ci_iprj(ind_block_addr, ind_idx));
+                    match ind_ci {
+                      KConstantInfo.Induct(_, _, _, nindices, nctors, _, _, _) =>
+                        let shape_ok = eq_zero(nindices) * eq_zero(nctors - 1);
                         match shape_ok {
                           0 => 0,
-                          1 =>
-                            match computed_is_rec_ind(induct_idx, top) {
+                          _ =>
+                            let struct_addr = compute_iprj_addr(ind_block_addr, ind_idx);
+                            -- Eta holds for structure-LIKE inductives only, which
+                            -- Lean defines as non-recursive on top of the shape
+                            -- test above (`isStructureLike` requires
+                            -- `isRec := false`). Firing on a recursive one-ctor
+                            -- inductive accepts pairs Lean's kernel rejects. The
+                            -- whnf-side struct-eta iota gates on the same
+                            -- predicate.
+                            match struct_is_rec(struct_addr) {
                               1 => 0,
-                              0 =>
-                                compare_struct_fields(induct_idx, num_params,
-                                                       num_fields, t, s_args, 0,
-                                                       types, top, addrs),
+                              _ =>
+                                -- The two sides must have def-eq TYPES.
+                                -- Without this the rule degenerates: for
+                                -- ANY `t` of ANY type it would compare
+                                -- `t` against `S.mk … (Proj S i t) …`,
+                                -- and `compare_struct_fields` builds
+                                -- exactly those projections, so the
+                                -- pointer fast path matches them and the
+                                -- pair is accepted. Those projections are
+                                -- synthesized inside def-eq and never
+                                -- inferred, so `k_infer_proj`'s own
+                                -- head-address gate never sees them.
+                                -- Mirrors the reference's
+                                -- "Types must be def-eq" check
+                                -- (crates/kernel/src/def_eq.rs), itself
+                                -- lean4lean's `tryEtaStructCore`.
+                                let t_ty = k_infer_only(t, types);
+                                let s_ty = k_infer_only(s, types);
+                                match k_is_def_eq(t_ty, s_ty, types) {
+                                  0 => 0,
+                                  _ =>
+                                    compare_struct_fields(struct_addr, nparams,
+                                                               nfields, t, s_args, 0, types),
+                                },
                             },
                         },
                       _ => 0,
@@ -429,220 +437,426 @@ def defEq := ⟦
     }
   }
 
-  fn compare_struct_fields(induct_idx: G, num_params: G, num_fields: G,
-                            t: KExpr, s_args: List‹KExpr›, i: G,
-                            types: List‹KExpr›,
-                            top: List‹&KConstantInfo›,
-                            addrs: List‹Addr›) -> G {
-    match num_fields - i {
+  fn compare_struct_fields(struct_addr: Addr, nparams: G, nfields: G,
+                                t: KExpr, s_args: List‹KExpr›, i: G,
+                                types: List‹KExpr›) -> G {
+    match nfields - i {
       0 => 1,
       _ =>
-        let proj_expr = store(KExprNode.Proj(induct_idx, i, t));
-        let s_field = list_lookup(s_args, num_params + i);
-        match k_is_def_eq(proj_expr, s_field, types, top, addrs) {
+        let proj_expr = store(KExprNode.Proj(struct_addr, i, t));
+        let s_field = list_lookup(s_args, nparams + i);
+        match k_is_def_eq(proj_expr, s_field, types) {
           0 => 0,
-          1 => compare_struct_fields(induct_idx, num_params, num_fields, t,
-                                       s_args, i + 1, types, top, addrs),
+          _ => compare_struct_fields(struct_addr, nparams, nfields, t,
+                                          s_args, i + 1, types),
         },
     }
   }
 
-  -- ============================================================================
-  -- Structural comparison + Lambda-eta after WHNF.
-  -- ============================================================================
-  -- Mirror: src/ix/kernel/def_eq.rs lambda-eta tier (both directions).
-  -- Every non-Lam `a` paired with Lam `b` falls through to symmetric eta
-  -- expansion (try_eta_expand swap), to accept `λx. axiom x ≡ axiom`.
-  fn k_is_def_eq_struct(a: KExpr, b: KExpr, types: List‹KExpr›,
-                        top: List‹&KConstantInfo›, addrs: List‹Addr›) -> G {
+  -- Synthesize the parent inductive's IPrj wrapper Addr for use as
+  -- the struct_addr in Proj nodes. Same recipe as Ingress'
+  -- projection_addr but specialized to Indc (no members lookup —
+  -- direct Ixon IPrj Constant + blake3).
+  fn compute_iprj_addr(block_addr: Addr, idx: G) -> Addr {
+    -- Range-check the index rather than truncating it: an unchecked
+    -- low-byte pack collides the synthesized wrapper addrs of members
+    -- 0 and 256.
+    let idx_u64 = idx_to_u64(idx);
+    let info = ConstantInfo.IPrj(InductiveProj.Mk(idx_u64, block_addr));
+    let proj_c = Constant.Mk(info,
+                              store(ListNode.Nil),
+                              store(ListNode.Nil),
+                              store(ListNode.Nil));
+    let bytes = put_constant(proj_c, store(ListNode.Nil));
+    bytes_to_addr(bytes)
+  }
+
+  -- If exactly one side is a Lam, eta-expand the non-Lam side and retry.
+  fn try_eta_swap(a: KExpr, b: KExpr, types: List‹KExpr›) -> G {
     match load(a) {
-      KExprNode.Srt(la) =>
+      KExprNode.Lam(ta, ba) =>
         match load(b) {
-          KExprNode.Srt(lb) => level_equal(la, lb),
-          KExprNode.Lam(ty_b, body_b) => try_eta_expand(ty_b, body_b, a, types, top, addrs),
+          KExprNode.Lam(_, _) => 0,
+          _ => try_eta_expand(ta, ba, b, types),
+        },
+      _ =>
+        match load(b) {
+          KExprNode.Lam(tb, bb) => try_eta_expand(tb, bb, a, types),
           _ => 0,
         },
+    }
+  }
 
-      KExprNode.BVar(ia) =>
-        match load(b) {
-          KExprNode.BVar(ib) =>
-            match ia - ib {
-              0 => 1,
+  -- Mirror try_unit_like (Kernel/DefEq.lean:211) / Rust
+  -- def_eq.rs:858-905 try_unit_like_eq: if `a`'s type whnfs to
+  -- `Const(I, _) args` for a single-ctor zero-field inductive
+  -- (PUnit, True, Unit-like structures), any two inhabitants are
+  -- definitionally equal — provided `b`'s type is def-eq to `a`'s.
+  -- Fires all over brecOn/below machinery (below-package PUnit slots).
+  fn try_unit_like(a: KExpr, b: KExpr, types: List‹KExpr›) -> G {
+    let ta = k_infer_only(a, types);
+    let ta_w = whnf(ta, types);
+    match is_unit_like_type(ta_w) {
+      0 => 0,
+      _ =>
+        let tb = k_infer_only(b, types);
+        k_is_def_eq(ta, tb, types),
+    }
+  }
+
+  -- 1 iff ty is `Const(I, _) args` for a 1-ctor 0-field inductive.
+  fn is_unit_like_type(ty: KExpr) -> G {
+    match collect_spine(ty) {
+      (head, _) =>
+        match load(head) {
+          KExprNode.Const(addr, _) =>
+            let ci = load(get_ci(addr));
+            match ci {
+              KConstantInfo.Induct(_, _, _, _, num_ctors, _, block, idx) =>
+                match num_ctors - 1 {
+                  0 =>
+                    let cci = load(get_ci_cprj(block, idx, 0));
+                    match cci {
+                      KConstantInfo.Ctor(_, _, _, _, _, _, nfields, _) =>
+                        match nfields {
+                          0 => 1,
+                          _ => 0,
+                        },
+                      _ => 0,
+                    },
+                  _ => 0,
+                },
               _ => 0,
             },
-          KExprNode.Lam(ty_b, body_b) => try_eta_expand(ty_b, body_b, a, types, top, addrs),
           _ => 0,
         },
+    }
+  }
 
-      KExprNode.Const(ia, lvls_a) =>
-        match load(b) {
-          KExprNode.Const(ib, lvls_b) =>
-            match ia - ib {
-              0 => k_is_def_eq_levels(lvls_a, lvls_b),
-              _ => 0,
-            },
-          KExprNode.Lam(ty_b, body_b) => try_eta_expand(ty_b, body_b, a, types, top, addrs),
+  -- Mirror crates/kernel/src: if `a`'s type is a Prop,
+  -- and `b`'s type is def-eq to `a`'s type, then a ≡ b as proof-terms.
+  -- Uses k_infer_only to avoid the def_eq ↔ check cycle.
+  fn try_proof_irrel(a: KExpr, b: KExpr, types: List‹KExpr›) -> G {
+    let a_ty = k_infer_only(a, types);
+    match is_prop_type(a_ty, types) {
+      0 => 0,
+      _ =>
+        let b_ty = k_infer_only(b, types);
+        k_is_def_eq(a_ty, b_ty, types),
+    }
+  }
+
+  -- Mirror crates/kernel/src: `λty. body` vs non-Lam
+  -- `b` → compare `body` vs `App(lift(b, 1, 0), BVar 0)` under the
+  -- extended ctx.
+  fn try_eta_expand(ty_a: KExpr, body_a: KExpr, b: KExpr,
+                        types: List‹KExpr›) -> G {
+    let b_lifted = expr_lift(b, 1, 0);
+    let bvar0 = store(KExprNode.BVar(0));
+    let b_app = store(KExprNode.App(b_lifted, bvar0));
+    let inner = store(ListNode.Cons(ty_a, types));
+    k_is_def_eq(body_a, b_app, inner)
+  }
+
+  -- 1 iff `whnf(infer_only(ty))` is `Sort 0`.
+  fn is_prop_type(ty: KExpr, types: List‹KExpr›) -> G {
+    let sort = k_infer_only(ty, types);
+    let sort_w = whnf(sort, types);
+    match load(sort_w) {
+      KExprNode.Srt(l) =>
+        match load(l) {
+          KLevelNode.Zero => 1,
           _ => 0,
         },
+      _ => 0,
+    }
+  }
+
+  -- Structural arm-by-arm equality on WHNF'd exprs. The Lit arm
+  -- continues into `k_is_def_eq_struct_go` directly (see there);
+  -- keep the two-name split so that call can bypass nothing but the
+  -- entry itself.
+  fn k_is_def_eq_struct(a: KExpr, b: KExpr, types: List‹KExpr›) -> G {
+    k_is_def_eq_struct_go(a, b, types)
+  }
 
+  fn k_is_def_eq_struct_go(a: KExpr, b: KExpr, types: List‹KExpr›) -> G {
+    match load(a) {
+      KExprNode.BVar(i) =>
+        match load(b) {
+          KExprNode.BVar(j) => match i - j { 0 => 1, _ => 0, },
+          _ => 0,
+        },
+      KExprNode.Srt(la) =>
+        match load(b) {
+          KExprNode.Srt(lb) => level_equal(la, lb),
+          _ => 0,
+        },
+      KExprNode.Const(addr_a, lvls_a) =>
+        match load(b) {
+          KExprNode.Const(addr_b, lvls_b) =>
+            -- Content equality decides which constant this is; pointer
+            -- inequality would not (see the `Addr` note in Core.lean).
+            match address_eq(addr_a, addr_b) {
+              1 => level_list_eq(lvls_a, lvls_b),
+              _ => try_lazy_delta_app(a, b, types),
+            },
+          _ => try_lazy_delta_app(a, b, types),
+        },
       KExprNode.App(fa, xa) =>
         match load(b) {
           KExprNode.App(fb, xb) =>
-            let f_eq = k_is_def_eq(fa, fb, types, top, addrs);
-            match f_eq {
-              1 => k_is_def_eq(xa, xb, types, top, addrs),
-              0 => 0,
+            match k_is_def_eq(fa, fb, types) {
+              0 => try_lazy_delta_app(a, b, types),
+              _ =>
+                match k_is_def_eq(xa, xb, types) {
+                  0 => try_lazy_delta_app(a, b, types),
+                  _ => 1,
+                },
             },
-          KExprNode.Lam(ty_b, body_b) => try_eta_expand(ty_b, body_b, a, types, top, addrs),
-          _ => 0,
+          _ => try_lazy_delta_app(a, b, types),
         },
-
-      KExprNode.Lam(ty_a, body_a) =>
+      KExprNode.Lam(ta, ba) =>
         match load(b) {
-          KExprNode.Lam(ty_b, body_b) =>
-            let ty_eq = k_is_def_eq(ty_a, ty_b, types, top, addrs);
-            match ty_eq {
-              1 =>
-                let inner = store(ListNode.Cons(ty_a, types));
-                k_is_def_eq(body_a, body_b, inner, top, addrs),
+          KExprNode.Lam(tb, bb) =>
+            match k_is_def_eq(ta, tb, types) {
               0 => 0,
+              _ =>
+                let types2 = store(ListNode.Cons(ta, types));
+                k_is_def_eq(ba, bb, types2),
             },
-          _ => try_eta_expand(ty_a, body_a, b, types, top, addrs),
+          _ => try_eta_expand(ta, ba, b, types),
         },
-
-      KExprNode.Forall(ty_a, body_a) =>
+      KExprNode.Forall(ta, ba) =>
         match load(b) {
-          KExprNode.Forall(ty_b, body_b) =>
-            let ty_eq = k_is_def_eq(ty_a, ty_b, types, top, addrs);
-            match ty_eq {
-              1 =>
-                let inner = store(ListNode.Cons(ty_a, types));
-                k_is_def_eq(body_a, body_b, inner, top, addrs),
+          KExprNode.Forall(tb, bb) =>
+            match k_is_def_eq(ta, tb, types) {
               0 => 0,
+              _ =>
+                let types2 = store(ListNode.Cons(ta, types));
+                k_is_def_eq(ba, bb, types2),
             },
-          KExprNode.Lam(ty_b, body_b) => try_eta_expand(ty_b, body_b, a, types, top, addrs),
           _ => 0,
         },
-
-      KExprNode.Let(ty_a, val_a, body_a) =>
+      KExprNode.Let(_, _, _) =>
+        -- whnf should have zeta-reduced Let already.
+        0,
+      KExprNode.Lit(la) =>
         match load(b) {
-          KExprNode.Let(ty_b, val_b, body_b) =>
-            let ty_eq = k_is_def_eq(ty_a, ty_b, types, top, addrs);
-            match ty_eq {
+          -- Compare the VALUES, not just the shapes: two Lits are def-eq
+          -- only when their payloads are equal. Answering 1 for any pair of
+          -- Lits would accept `Lit 5 ≟ Lit 6` and certify `Nat.add 2 3 = 6`.
+          -- The earlier def_eq_nat tier handles offset-shaped Nat pairs, but
+          -- nothing guarantees it fired before this point, and it never
+          -- covers Str.
+          KExprNode.Lit(lb) => literal_eq(la, lb),
+          _ =>
+            -- Lit vs non-Lit: convert `a` to ctor form (Nat.zero /
+            -- App(Nat.succ, Lit(k-1))) and retry STRUCTURALLY. Handles
+            -- the `Lit(Nat 0) ≡ Const(Nat.zero)` case that comes up
+            -- when one side reduces via nat_lit_to_ctor and the other
+            -- doesn't ( residual — Nat.pred_le).
+            -- MUST NOT re-enter full k_is_def_eq: its whnf collapses
+            -- the succ-wrapped form straight back to the same interned
+            -- Lit (nat prim), producing an infinite expand/collapse
+            -- cycle whenever `b` is a stuck non-ctor app.
+            let a_ctor = nat_lit_to_ctor_or_self(a);
+            match ptr_val(a_ctor) - ptr_val(a) {
+              0 => 0,  -- didn't change, avoid infinite loop
+              _ => k_is_def_eq_struct_go(a_ctor, b, types),
+            },
+        },
+      KExprNode.Proj(struct_a, fidx_a, ea) =>
+        match load(b) {
+          KExprNode.Proj(struct_b, fidx_b, eb) =>
+            -- Content equality decides; pointer inequality would not.
+            match address_eq(struct_a, struct_b) {
               1 =>
-                let v_eq = k_is_def_eq(val_a, val_b, types, top, addrs);
-                match v_eq {
-                  1 =>
-                    let inner = store(ListNode.Cons(ty_a, types));
-                    k_is_def_eq(body_a, body_b, inner, top, addrs),
-                  0 => 0,
+                match fidx_a - fidx_b {
+                  0 => k_is_def_eq(ea, eb, types),
+                  _ => 0,
                 },
-              0 => 0,
+              _ => 0,
             },
-          KExprNode.Lam(ty_b, body_b) => try_eta_expand(ty_b, body_b, a, types, top, addrs),
           _ => 0,
         },
+    }
+  }
 
-      KExprNode.Lit(la) =>
-        match load(b) {
-          KExprNode.Lit(lb) => literal_eq(la, lb),
-          KExprNode.Lam(ty_b, body_b) => try_eta_expand(ty_b, body_b, a, types, top, addrs),
-          _ => 0,
+  -- Multi-step lazy-delta reduction loop (mirror Tier 4).
+  -- Both sides possibly Const-Defn/Thm-headed. Unfold one side per
+  -- iteration (prefer higher-rank/hint), whnf result, retry def_eq.
+  -- Fuel-bounded to prevent runaway on cyclic unfolds. Returns 0 on
+  -- exhaustion; caller falls through to structural compare.
+  fn lazy_delta_loop(a: KExpr, b: KExpr, fuel: G,
+                          types: List‹KExpr›) -> G {
+    match fuel {
+      0 => 0,
+      _ =>
+        match ptr_val(a) - ptr_val(b) {
+          0 => 1,
+          _ =>
+        let (a_addr, a_is_const) = head_addr(a);
+        let (b_addr, b_is_const) = head_addr(b);
+        match a_is_const {
+          1 =>
+            match b_is_const {
+              1 =>
+                -- In-loop app-congruence (mirror lazy_delta_loop:773):
+                -- same head + def-eq levels + pairwise-def-eq args decides
+                -- WITHOUT unfolding — with Thm heads stuck, most proof-app
+                -- pairs settle here.
+                match try_def_eq_app(a, b, types) {
+                  1 => 1,
+                  _ => lazy_delta_step_const_const(a_addr, b_addr, a, b,
+                                                       fuel, types),
+                },
+              _ => lazy_delta_a_const_b_proj(a_addr, a, b, fuel, types),
+            },
+          _ =>
+            match b_is_const {
+              1 => lazy_delta_b_const_a_proj(b_addr, a, b, fuel, types),
+              _ =>
+                -- Neither Const-headed at spine head. Try unfold_proj_app
+                -- on both — if either side is Proj-headed with a
+                -- delta-eligible inner Const, unfold inner and rewrap.
+                lazy_delta_both_proj(a, b, fuel, types),
+            },
+        },
         },
+    }
+  }
 
-      KExprNode.Proj(tidx_a, fidx_a, ea) =>
-        match load(b) {
-          KExprNode.Proj(tidx_b, fidx_b, eb) =>
-            let same = eq_zero(tidx_a - tidx_b) * eq_zero(fidx_a - fidx_b);
-            match same {
-              1 => k_is_def_eq(ea, eb, types, top, addrs),
-              0 => 0,
+  -- Reducibility rank for lazy-delta unfold ordering (mirror
+  -- delta_rank): Defn carries the ch 3 hint; Thm and everything else
+  -- rank 0.
+  fn delta_rank(ci: KConstantInfo) -> G {
+    match ci {
+      KConstantInfo.Defn(_, _, _, _, hint) => hint,
+      _ => 0,
+    }
+  }
+
+  -- Both heads Const, congruence missed. Rank-ordered unfold (mirror
+  -- lazy_delta_step_const_const / Rust lazy_delta_reduction_step):
+  -- unfold the higher-rank side so both sides meet at the same
+  -- definitional height; equal ranks unfold both.
+  fn lazy_delta_step_const_const(a_addr: Addr, b_addr: Addr, a: KExpr,
+                                       b: KExpr, fuel: G,
+                                       types: List‹KExpr›) -> G {
+    let a_ci = load(get_ci(a_addr));
+    let b_ci = load(get_ci(b_addr));
+    let ae = is_defn_or_thm(a_ci);
+    let be = is_defn_or_thm(b_ci);
+    match ae {
+      0 =>
+        match be {
+          0 => 0,
+          _ => unfold_b_and_loop(a, b, fuel, types),
+        },
+      _ =>
+        match be {
+          0 => unfold_a_and_loop(a, b, fuel, types),
+          _ =>
+            let ar = delta_rank(a_ci);
+            let br = delta_rank(b_ci);
+            match u32_less_than(br, ar) {
+              1 => unfold_a_and_loop(a, b, fuel, types),
+              _ =>
+                match u32_less_than(ar, br) {
+                  1 => unfold_b_and_loop(a, b, fuel, types),
+                  _ => unfold_both_and_loop(a, b, fuel, types),
+                },
             },
-          KExprNode.Lam(ty_b, body_b) => try_eta_expand(ty_b, body_b, a, types, top, addrs),
-          _ => 0,
         },
     }
   }
 
-  -- ============================================================================
-  -- Lambda eta expansion (Rust def_eq.rs:1068-1100).
-  --
-  -- We have `λ(ty_a). body_a` on one side and a non-Lam `b` on the other.
-  -- Build the wrap `λ(ty_a). (lift(b, 1, 0)) #0` and compare its body
-  -- against body_a.
-  --
-  -- Equivalently: compare `body_a` vs `App(lift(b, 1, 0), BVar(0))`.
-  -- ============================================================================
-  fn try_eta_expand(ty_a: KExpr, body_a: KExpr, b: KExpr,
-                    types: List‹KExpr›,
-                    top: List‹&KConstantInfo›, addrs: List‹Addr›) -> G {
-    let b_lifted = expr_lift(b, 1, 0);
-    let bvar0 = store(KExprNode.BVar(0));
-    let b_app = store(KExprNode.App(b_lifted, bvar0));
-    let inner = store(ListNode.Cons(ty_a, types));
-    k_is_def_eq(body_a, b_app, inner, top, addrs)
+  fn unfold_a_and_loop(a: KExpr, b: KExpr, fuel: G,
+                           types: List‹KExpr›) -> G {
+    match delta_unfold(a) {
+      (1, a2) =>
+        let aw = whnf(a2, types);
+        lazy_delta_loop(aw, b, fuel - 1, types),
+      _ => 0,
+    }
   }
 
-  -- ============================================================================
-  -- Level list equality.
-  -- ============================================================================
-  fn k_is_def_eq_levels(a: List‹KLevel›, b: List‹KLevel›) -> G {
-    match load(a) {
-      ListNode.Nil =>
-        match load(b) {
-          ListNode.Nil => 1,
+  fn unfold_b_and_loop(a: KExpr, b: KExpr, fuel: G,
+                           types: List‹KExpr›) -> G {
+    match delta_unfold(b) {
+      (1, b2) =>
+        let bw = whnf(b2, types);
+        lazy_delta_loop(a, bw, fuel - 1, types),
+      _ => 0,
+    }
+  }
+
+  fn unfold_both_and_loop(a: KExpr, b: KExpr, fuel: G,
+                              types: List‹KExpr›) -> G {
+    match delta_unfold(a) {
+      (1, a2) =>
+        match delta_unfold(b) {
+          (1, b2) =>
+            let aw = whnf(a2, types);
+            let bw = whnf(b2, types);
+            lazy_delta_loop(aw, bw, fuel - 1, types),
           _ => 0,
         },
-      ListNode.Cons(la, ra) =>
-        match load(b) {
-          ListNode.Nil => 0,
-          ListNode.Cons(lb, rb) =>
-            let l_eq = level_equal(la, lb);
-            match l_eq {
-              1 => k_is_def_eq_levels(ra, rb),
-              0 => 0,
+      _ => 0,
+    }
+  }
+
+  -- a is Const-headed spine; b is Proj-headed. Mirror
+  -- lazy_delta_step_a_const: try unfold_proj_app on b, else unfold a.
+  fn lazy_delta_a_const_b_proj(a_addr: Addr, a: KExpr, b: KExpr, fuel: G,
+                                       types: List‹KExpr›) -> G {
+    let a_ci = load(get_ci(a_addr));
+    match is_defn_or_thm(a_ci) {
+      0 => 0,
+      _ =>
+        match try_unfold_proj_app(b) {
+          (1, b2) =>
+            let bw = whnf(b2, types);
+            match k_is_def_eq(a, bw, types) {
+              1 => 1,
+              _ => lazy_delta_loop(a, bw, fuel - 1, types),
+            },
+          _ =>
+            let au = try_unfold_head(a, a_ci, types);
+            match au {
+              (1, aw) =>
+                match k_is_def_eq(aw, b, types) {
+                  1 => 1,
+                  _ => lazy_delta_loop(aw, b, fuel - 1, types),
+                },
+              _ => 0,
             },
         },
     }
   }
 
-  -- ============================================================================
-  -- Lazy-delta app-congruence (Tier 1.5 of k_is_def_eq).
-  -- Mirror: src/ix/kernel/def_eq.rs:1262-1287 try_def_eq_app.
-  --
-  -- When both sides reduce syntactically to `Const(idx, lvls) ◦ args` with
-  -- matching idx, level list, and arg count, recurse on args directly via
-  -- k_is_def_eq. Bypasses delta+beta of the def's body for the common
-  -- congruence case (`f x ≡ f y` whenever `x ≡ y`).
-  --
-  -- Sound: returns 1 only when args recursively def-eq; returns 0 to fall
-  -- through to the regular WHNF-based pipeline.
-  -- ============================================================================
-  fn try_lazy_delta_app(a: KExpr, b: KExpr, types: List‹KExpr›,
-                        top: List‹&KConstantInfo›, addrs: List‹Addr›) -> G {
-    match collect_spine(a) {
-      (ah, aa) =>
-        match collect_spine(b) {
-          (bh, bb) =>
-            match load(ah) {
-              KExprNode.Const(ai, al) =>
-                match load(bh) {
-                  KExprNode.Const(bi, bl) =>
-                    match ai - bi {
-                      0 =>
-                        match k_is_def_eq_levels(al, bl) {
-                          0 => 0,
-                          1 =>
-                            let len_a = list_length(aa);
-                            let len_b = list_length(bb);
-                            match len_a - len_b {
-                              0 => is_def_eq_arg_list(aa, bb, types, top, addrs),
-                              _ => 0,
-                            },
-                        },
-                      _ => 0,
-                    },
-                  _ => 0,
+  -- Symmetric.
+  fn lazy_delta_b_const_a_proj(b_addr: Addr, a: KExpr, b: KExpr, fuel: G,
+                                       types: List‹KExpr›) -> G {
+    let b_ci = load(get_ci(b_addr));
+    match is_defn_or_thm(b_ci) {
+      0 => 0,
+      _ =>
+        match try_unfold_proj_app(a) {
+          (1, a2) =>
+            let aw = whnf(a2, types);
+            match k_is_def_eq(aw, b, types) {
+              1 => 1,
+              _ => lazy_delta_loop(aw, b, fuel - 1, types),
+            },
+          _ =>
+            let bu = try_unfold_head(b, b_ci, types);
+            match bu {
+              (1, bw) =>
+                match k_is_def_eq(a, bw, types) {
+                  1 => 1,
+                  _ => lazy_delta_loop(a, bw, fuel - 1, types),
                 },
               _ => 0,
             },
@@ -650,44 +864,41 @@ def defEq := ⟦
     }
   }
 
-  fn is_def_eq_arg_list(aa: List‹KExpr›, bb: List‹KExpr›,
-                        types: List‹KExpr›, top: List‹&KConstantInfo›,
-                        addrs: List‹Addr›) -> G {
-    match load(aa) {
-      ListNode.Nil =>
-        match load(bb) {
-          ListNode.Nil => 1,
-          _ => 0,
+  -- Both are Proj-headed spines. Try unfold_proj_app on either or both.
+  fn lazy_delta_both_proj(a: KExpr, b: KExpr, fuel: G,
+                               types: List‹KExpr›) -> G {
+    let ua = try_unfold_proj_app(a);
+    let ub = try_unfold_proj_app(b);
+    match ua {
+      (1, a2) =>
+        let aw = whnf(a2, types);
+        match ub {
+          (1, b2) =>
+            let bw = whnf(b2, types);
+            match k_is_def_eq(aw, bw, types) {
+              1 => 1,
+              _ => lazy_delta_loop(aw, bw, fuel - 1, types),
+            },
+          _ =>
+            match k_is_def_eq(aw, b, types) {
+              1 => 1,
+              _ => lazy_delta_loop(aw, b, fuel - 1, types),
+            },
         },
-      ListNode.Cons(a, ar) =>
-        match load(bb) {
-          ListNode.Nil => 0,
-          ListNode.Cons(b, br) =>
-            match k_is_def_eq(a, b, types, top, addrs) {
-              0 => 0,
-              1 => is_def_eq_arg_list(ar, br, types, top, addrs),
+      _ =>
+        match ub {
+          (1, b2) =>
+            let bw = whnf(b2, types);
+            match k_is_def_eq(a, bw, types) {
+              1 => 1,
+              _ => lazy_delta_loop(a, bw, fuel - 1, types),
             },
+          _ => 0,
         },
     }
   }
 
-  -- ============================================================================
-  -- Lazy-delta unfold loop (Tier 4 of k_is_def_eq).
-  -- Mirror: src/ix/kernel/def_eq.rs:1418-1483 lazy_delta_reduction_step
-  -- + outer fuel loop in def_eq.rs:1383-1414.
-  --
-  -- After Tier 2 whnf may leave both sides stuck on Const-headed
-  -- Defn(Opaque) or Thm. Iteratively unfolds one side per rank-cmp:
-  --   * Both delta-eligible, ar > br : unfold a.
-  --   * Both delta-eligible, ar < br : unfold b.
-  --   * Both delta-eligible, ar == br: unfold both.
-  --   * Only a eligible: unfold a.
-  --   * Only b eligible: unfold b.
-  --   * Neither: stuck → fall through to structural compare.
-  -- After each unfold, whnf the result and recurse. Fuel-bounded.
-  -- ============================================================================
-  fn is_delta_eligible(idx: G, top: List‹&KConstantInfo›) -> G {
-    let ci = load(list_lookup(top, idx));
+  fn is_defn_or_thm(ci: KConstantInfo) -> G {
     match ci {
       KConstantInfo.Defn(_, _, _, _, _) => 1,
       KConstantInfo.Thm(_, _, _) => 1,
@@ -695,22 +906,33 @@ def defEq := ⟦
     }
   }
 
-  fn delta_rank(idx: G, top: List‹&KConstantInfo›) -> G {
-    let ci = load(list_lookup(top, idx));
-    match ci {
-      KConstantInfo.Defn(_, _, _, _, hint) => hint,
-      _ => 0,
+  -- Mirror try_unfold_proj_app (Kernel/DefEq.lean:732). If e collects
+  -- to Proj(_, _, inner) spine and inner is delta-eligible Const-headed,
+  -- unfold inner and rewrap Proj + reapply spine.
+  fn try_unfold_proj_app(e: KExpr) -> (G, KExpr) {
+    match collect_spine(e) {
+      (head, spine) =>
+        match load(head) {
+          KExprNode.Proj(struct_addr, fidx, inner) =>
+            match delta_unfold(inner) {
+              (1, inner2) =>
+                let new_head = store(KExprNode.Proj(struct_addr, fidx, inner2));
+                (1, apply_spine(new_head, spine)),
+              _ => (0, e),
+            },
+          _ => (0, e),
+        },
     }
   }
 
-  -- Unfold a delta-eligible Const-headed expr to its body[lvls] applied
-  -- to the spine. Returns (1, expr2) on success, (0, e) otherwise.
-  fn delta_unfold(e: KExpr, top: List‹&KConstantInfo›) -> (G, KExpr) {
+  -- Delta-unfold Const-headed e: replace Const with its Defn/Thm body,
+  -- keeping the spine. Returns (0, e) if head isn't Const-Defn/Thm.
+  fn delta_unfold(e: KExpr) -> (G, KExpr) {
     match collect_spine(e) {
       (head, spine) =>
         match load(head) {
-          KExprNode.Const(idx, lvls) =>
-            let ci = load(list_lookup(top, idx));
+          KExprNode.Const(addr, lvls) =>
+            let ci = load(get_ci(addr));
             match ci {
               KConstantInfo.Defn(_, _, value, _, _) =>
                 let body = expr_inst_levels(value, lvls);
@@ -725,197 +947,72 @@ def defEq := ⟦
     }
   }
 
-  -- Mirror: src/ix/kernel/def_eq.rs:1539-1549 try_unfold_proj_app.
-  -- If e collects to App-spine on Proj(_, _, inner) where inner is itself
-  -- delta-eligible Const-headed, unfold inner's body and rewrap the Proj.
-  -- Returns (1, e2) on progress, (0, e) otherwise.
-  fn try_unfold_proj_app(e: KExpr, top: List‹&KConstantInfo›) -> (G, KExpr) {
-    match collect_spine(e) {
-      (head, spine) =>
-        match load(head) {
-          KExprNode.Proj(tidx, fidx, inner) =>
-            match delta_unfold(inner, top) {
-              (1, inner2) =>
-                let new_head = store(KExprNode.Proj(tidx, fidx, inner2));
-                (1, apply_spine(new_head, spine)),
-              (0, _) => (0, e),
-            },
-          _ => (0, e),
-        },
-    }
-  }
-
-  fn lazy_delta_loop(a: KExpr, b: KExpr, fuel: G, types: List‹KExpr›,
-                     top: List‹&KConstantInfo›, addrs: List‹Addr›) -> (G, G) {
-    match fuel {
-      0 => (0, 0),
+  -- Lazy delta: unfold Defn on one side (prefer whichever has body),
+  -- retry. On stuck (neither is Defn), give up.
+  fn try_lazy_delta_app(a: KExpr, b: KExpr, types: List‹KExpr›) -> G {
+    let (a_addr, a_is_const) = head_addr(a);
+    let (b_addr, b_is_const) = head_addr(b);
+    match a_is_const {
+      0 => 0,
       _ =>
-        match ptr_val(a) - ptr_val(b) {
-          0 => (1, 1),
+        match b_is_const {
+          0 => 0,
           _ =>
-            -- Hoist heads once; structural congruence Tier 1 only fires when
-            -- both heads are Const (avoids try_lazy_delta_app's redundant
-            -- collect_spine when one side is Proj/Lam/etc).
-            -- Mirror src/ix/kernel/def_eq.rs:1418-1495: when one side is
-            -- Const-delta-eligible and the other isn't (Proj, Sort, Lam,
-            -- Forall, Lit, …), unfold the Const side regardless of the
-            -- other head's shape. The (Const, Proj) / (Proj, Const) cases
-            -- are subsumed by the generalized step helpers, since
-            -- try_unfold_proj_app is a no-op on non-Proj heads.
-            match collect_spine(a) {
-              (ah, aa) =>
-                match collect_spine(b) {
-                  (bh, bb) =>
-                    match load(ah) {
-                      KExprNode.Const(ai, al) =>
-                        match load(bh) {
-                          KExprNode.Const(bi, bl) =>
-                            match try_const_app_congruence(ai, al, aa, bi, bl, bb,
-                                                            types, top, addrs) {
-                              1 => (1, 1),
-                              _ => lazy_delta_step_const_const(ai, bi, a, b, fuel,
-                                                                types, top, addrs),
-                            },
-                          _ => lazy_delta_step_a_const(ai, a, b, fuel, types, top, addrs),
-                        },
-                      _ =>
-                        match load(bh) {
-                          KExprNode.Const(bi, _) =>
-                            lazy_delta_step_b_const(bi, a, b, fuel, types, top, addrs),
-                          _ => (0, 0),
-                        },
-                    },
+            let a_ci = load(get_ci(a_addr));
+            let b_ci = load(get_ci(b_addr));
+            let a_unfolded = try_unfold_head(a, a_ci, types);
+            let b_unfolded = try_unfold_head(b, b_ci, types);
+            match a_unfolded {
+              (1, aw) =>
+                match b_unfolded {
+                  (1, bw) => k_is_def_eq(aw, bw, types),
+                  _ => k_is_def_eq(aw, b, types),
                 },
-            },
-        },
-    }
-  }
-
-  -- Const-vs-Const spine congruence: same idx, def-eq levels, same arity,
-  -- pairwise def-eq args. Inner of try_lazy_delta_app without the head
-  -- loads (caller already did them).
-  fn try_const_app_congruence(ai: G, al: List‹KLevel›, aa: List‹KExpr›,
-                              bi: G, bl: List‹KLevel›, bb: List‹KExpr›,
-                              types: List‹KExpr›, top: List‹&KConstantInfo›,
-                              addrs: List‹Addr›) -> G {
-    match ai - bi {
-      0 =>
-        match k_is_def_eq_levels(al, bl) {
-          0 => 0,
-          1 =>
-            let len_a = list_length(aa);
-            let len_b = list_length(bb);
-            match len_a - len_b {
-              0 => is_def_eq_arg_list(aa, bb, types, top, addrs),
-              _ => 0,
-            },
-        },
-      _ => 0,
-    }
-  }
-
-  fn lazy_delta_step_const_const(ai: G, bi: G, a: KExpr, b: KExpr, fuel: G,
-                                 types: List‹KExpr›, top: List‹&KConstantInfo›,
-                                 addrs: List‹Addr›) -> (G, G) {
-    let ae = is_delta_eligible(ai, top);
-    let be = is_delta_eligible(bi, top);
-    match ae {
-      0 =>
-        match be {
-          0 => (0, 0),
-          1 => unfold_b_and_loop(a, b, fuel, types, top, addrs),
-          _ => (0, 0),
-        },
-      1 =>
-        match be {
-          0 => unfold_a_and_loop(a, b, fuel, types, top, addrs),
-          1 =>
-            let ar = delta_rank(ai, top);
-            let br = delta_rank(bi, top);
-            match u32_less_than(br, ar) {
-              1 => unfold_a_and_loop(a, b, fuel, types, top, addrs),
-              0 =>
-                match u32_less_than(ar, br) {
-                  1 => unfold_b_and_loop(a, b, fuel, types, top, addrs),
-                  0 => unfold_both_and_loop(a, b, fuel, types, top, addrs),
+              (0, _) =>
+                match b_unfolded {
+                  (1, bw) => k_is_def_eq(a, bw, types),
+                  _ => 0,
                 },
             },
-          _ => (0, 0),
         },
-      _ => (0, 0),
     }
   }
 
-  -- a is Const-headed at idx ai; b is anything else (Proj, Sort, Lam, …).
-  -- Mirror Rust def_eq.rs:1438-1445 (a_delta && !b_delta branch).
-  -- If a-delta-eligible, try try_unfold_proj_app(b) (no-op for non-Proj b);
-  -- else unfold a.
-  fn lazy_delta_step_a_const(ai: G, a: KExpr, b: KExpr, fuel: G,
-                              types: List‹KExpr›, top: List‹&KConstantInfo›,
-                              addrs: List‹Addr›) -> (G, G) {
-    match is_delta_eligible(ai, top) {
-      0 => (0, 0),
-      1 =>
-        match try_unfold_proj_app(b, top) {
-          (1, b2) =>
-            let bw = whnf(b2, types, top, addrs);
-            lazy_delta_loop(a, bw, fuel - 1, types, top, addrs),
-          (0, _) => unfold_a_and_loop(a, b, fuel, types, top, addrs),
+  -- Extract Const head's addr from a spine expr. Returns (addr, is_const).
+  fn head_addr(e: KExpr) -> (Addr, G) {
+    match collect_spine(e) {
+      (head, _) =>
+        match load(head) {
+          KExprNode.Const(addr, _) => (addr, 1),
+          _ => (store([0u8; 32]), 0),
         },
-      _ => (0, 0),
     }
   }
 
-  -- b is Const-headed at idx bi; a is anything else. Symmetric to the above.
-  -- Mirror Rust def_eq.rs:1446-1453 (!a_delta && b_delta branch).
-  fn lazy_delta_step_b_const(bi: G, a: KExpr, b: KExpr, fuel: G,
-                              types: List‹KExpr›, top: List‹&KConstantInfo›,
-                              addrs: List‹Addr›) -> (G, G) {
-    match is_delta_eligible(bi, top) {
-      0 => (0, 0),
-      1 =>
-        match try_unfold_proj_app(a, top) {
-          (1, a2) =>
-            let aw = whnf(a2, types, top, addrs);
-            lazy_delta_loop(aw, b, fuel - 1, types, top, addrs),
-          (0, _) => unfold_b_and_loop(a, b, fuel, types, top, addrs),
+  -- If ci is a Defn or Thm, delta-unfold its body, reapply the spine,
+  -- and whnf. Thm must go through delta_unfold explicitly — whnf
+  -- keeps Thm heads stuck (mirror), so `whnf(e)` alone would
+  -- return `e` unchanged for Thm and stall the lazy-delta loop.
+  fn try_unfold_head(e: KExpr, ci: KConstantInfo,
+                         types: List‹KExpr›) -> (G, KExpr) {
+    match ci {
+      -- Defn must ALSO go through the explicit delta_unfold, not
+      -- `whnf(e)`: offset-stuck compact forms (`Nat.add/div/mod base
+      -- lit`, whnf verdict 2) are whnf-FIXPOINTS, so "unfold via whnf"
+      -- returns the same pointer and the lazy-delta ladder recurses on
+      -- identical args forever. Explicit body substitution guarantees
+      -- progress (mirror delta_unfold).
+      KConstantInfo.Defn(_, _, _, _, _) =>
+        match delta_unfold(e) {
+          (1, e2) => (1, whnf(e2, types)),
+          _ => (0, e),
         },
-      _ => (0, 0),
-    }
-  }
-
-  fn unfold_a_and_loop(a: KExpr, b: KExpr, fuel: G, types: List‹KExpr›,
-                       top: List‹&KConstantInfo›, addrs: List‹Addr›) -> (G, G) {
-    match delta_unfold(a, top) {
-      (1, a2) =>
-        let aw = whnf(a2, types, top, addrs);
-        lazy_delta_loop(aw, b, fuel - 1, types, top, addrs),
-      (0, _) => (0, 0),
-    }
-  }
-
-  fn unfold_b_and_loop(a: KExpr, b: KExpr, fuel: G, types: List‹KExpr›,
-                       top: List‹&KConstantInfo›, addrs: List‹Addr›) -> (G, G) {
-    match delta_unfold(b, top) {
-      (1, b2) =>
-        let bw = whnf(b2, types, top, addrs);
-        lazy_delta_loop(a, bw, fuel - 1, types, top, addrs),
-      (0, _) => (0, 0),
-    }
-  }
-
-  fn unfold_both_and_loop(a: KExpr, b: KExpr, fuel: G, types: List‹KExpr›,
-                          top: List‹&KConstantInfo›, addrs: List‹Addr›) -> (G, G) {
-    match delta_unfold(a, top) {
-      (1, a2) =>
-        match delta_unfold(b, top) {
-          (1, b2) =>
-            let aw = whnf(a2, types, top, addrs);
-            let bw = whnf(b2, types, top, addrs);
-            lazy_delta_loop(aw, bw, fuel - 1, types, top, addrs),
-          (0, _) => (0, 0),
+      KConstantInfo.Thm(_, _, _) =>
+        match delta_unfold(e) {
+          (1, e2) => (1, whnf(e2, types)),
+          _ => (0, e),
         },
-      (0, _) => (0, 0),
+      _ => (0, e),
     }
   }
 ⟧
diff --git a/Ix/IxVM/Kernel/Inductive.lean b/Ix/IxVM/Kernel/Inductive.lean
deleted file mode 100644
index 7bb6ce410..000000000
--- a/Ix/IxVM/Kernel/Inductive.lean
+++ /dev/null
@@ -1,3409 +0,0 @@
-module
-public import Ix.Aiur.Meta
-public import Ix.IxVM.KernelTypes
-
-public section
-
-namespace IxVM
-
-/-! ## Inductive block validation
-
-Mirror: `src/ix/kernel/inductive.rs` (parameter agreement, return-type
-validation, universe constraints, strict positivity, recursor synthesis).
-
-Structure-only validation, no name diagnostics.
--/
-
--- The Aiur quotation below is at the elaborator's default recursion
--- limit; nested-statement chains (dbg!/sord_then continuations) push
--- past it.
-set_option maxRecDepth 65536 in
-def inductive_check := ⟦
-  -- Mirror: src/ix/kernel/inductive.rs:1968-2080 check_ctor_return_type.
-  -- Validates that a ctor's declared type, after peeling
-  -- `n_params + n_fields` Foralls, is a syntactic `Indc(params, indices)`
-  -- application:
-  --   * head is `Const(ind_idx, lvls)`
-  --   * `lvls.len() == ind_num_lvls`
-  --   * each `lvls[i]` is `Param(i)`
-  --   * spine args count is `n_params + n_indices`
-  --   * first `n_params` args are the param BVars (de Bruijn equivalents
-  --     of Rust's param fvars at line 1986-1994).
-  --
-  -- Failure path: `assert_eq!(0, 1)` panics the Aiur execution per the
-  -- kernel's accept/reject convention.
-  fn check_ctor_return_type(ctor_ty: KExpr,
-                            n_params: G, n_indices: G, n_fields: G,
-                            ind_idx: G, ind_num_lvls: G,
-                            top: List‹&KConstantInfo›) {
-    let body = peel_n_foralls(ctor_ty, n_params + n_fields);
-    let pair = collect_spine(body);
-    match pair {
-      (head, args) =>
-        match load(head) {
-          KExprNode.Const(idx, lvls) =>
-            assert_eq!(idx, ind_idx);
-            assert_lvls_are_params(lvls, ind_num_lvls, 0);
-            let args_len = list_length(args);
-            assert_eq!(args_len, n_params + n_indices);
-            assert_first_args_are_param_bvars(args, n_params, n_fields, 0);
-            -- Index args must not mention block inductives (rejects e.g.
-            -- `mk : I (I x)` — a reflexive occurrence in index position).
-            -- Mirror: src/ix/kernel/inductive.rs:2088-2095.
-            let idx_args = list_drop(args, n_params);
-            let block_idxs = derive_block_member_idxs(ind_idx, top);
-            assert_eq!(list_any_mentions(idx_args, block_idxs), 0);
-            (),
-        },
-    }
-  }
-
-  -- Validate the inductive's own shape AND every constructor (param
-  -- agreement, return type, field universes, positivity).
-  -- Mirror: src/ix/kernel/inductive.rs:148-297 check_inductive_member.
-  -- The per-const dispatch in Check.lean also runs the same per-ctor
-  -- checks when each Ctor const is checked; bundling them on the
-  -- inductive makes it
-  -- self-contained under subject-only checking (the arena's
-  -- `verify_const`) and lets `check_recursor_member` gate on a valid
-  -- major (coherence gate, inductive.rs:4089-4102) — recursor gen
-  -- succeeds syntactically even for unsound inductives. Aiur memoizes
-  -- fn calls, so the closure-wide double coverage is cache hits.
-  -- Cycle invariant (per Rust): never calls back into recursor checks.
-  fn check_inductive_shape(ind_pos: G, top: List‹&KConstantInfo›,
-                           addrs: List‹Addr›) {
-    let ci = load(list_lookup(top, ind_pos));
-    match ci {
-      KConstantInfo.Induct(num_lvls, ty, n_params, n_indices, ctor_indices, _, _) =>
-        -- The inductive type must peel params+indices down to a Sort;
-        -- `get_result_sort_level`'s non-exhaustive matches reject
-        -- anything else. Mirror: inductive.rs:183-186.
-        let ind_level = get_result_sort_level(ty, n_params + n_indices,
-                                              store(ListNode.Nil), top, addrs);
-        check_inductive_shape_ctors(ctor_indices, ind_pos, ty, num_lvls,
-                                    n_params, n_indices, ind_level, 0,
-                                    top, addrs),
-      -- Non-inductive majors (e.g. Quot) are validated by their own
-      -- check_const arms.
-      _ => (),
-    }
-  }
-
-  fn check_inductive_shape_ctors(ctor_indices: List‹G›, ind_pos: G,
-                                 ind_ty: KExpr, num_lvls: G,
-                                 n_params: G, n_indices: G,
-                                 ind_level: KLevel, expected_cidx: G,
-                                 top: List‹&KConstantInfo›,
-                                 addrs: List‹Addr›) {
-    match load(ctor_indices) {
-      ListNode.Nil => (),
-      ListNode.Cons(ctor_idx, rest) =>
-        let ctor_ci = load(list_lookup(top, ctor_idx));
-        match ctor_ci {
-          KConstantInfo.Ctor(_, cty, c_induct, c_cidx, c_np, c_nf, _) =>
-            assert_eq!(c_induct, ind_pos);
-            assert_eq!(c_cidx, expected_cidx);
-            assert_eq!(c_np, n_params);
-            check_param_agreement(ind_ty, cty, n_params, top, addrs);
-            check_ctor_return_type(cty, c_np, n_indices, c_nf, ind_pos,
-                                   num_lvls, top);
-            check_field_universes(cty, c_np, ind_level,
-                                  store(ListNode.Nil), top, addrs);
-            check_positivity(cty, c_np, ind_pos, store(ListNode.Nil),
-                             top, addrs);
-            check_inductive_shape_ctors(rest, ind_pos, ind_ty, num_lvls,
-                                        n_params, n_indices, ind_level,
-                                        expected_cidx + 1, top, addrs),
-          _ =>
-            assert_eq!(0, 1);
-            (),
-        },
-    }
-  }
-
-  -- Peel `n` Foralls off the head, return the body. Panics if fewer
-  -- Foralls than requested.
-  fn peel_n_foralls(e: KExpr, n: G) -> KExpr {
-    match n {
-      0 => e,
-      _ =>
-        match load(e) {
-          KExprNode.Forall(_, body) => peel_n_foralls(body, n - 1),
-        },
-    }
-  }
-
-  -- Each `lvls[i]` must be `Param(expected_start + i)` for i in 0..count.
-  fn assert_lvls_are_params(lvls: List‹KLevel›, count: G, idx: G) {
-    match count {
-      0 =>
-        -- Mirror: src/ix/kernel/inductive.rs:2018: us.len() == ind_lvls.
-        -- At base case all expected lvls consumed; remaining list must be empty.
-        assert_eq!(list_length(lvls), 0);
-        (),
-      _ =>
-        match load(lvls) {
-          ListNode.Cons(l, rest) =>
-            match load(l) {
-              KLevelNode.Param(i) =>
-                assert_eq!(i, idx);
-                assert_lvls_are_params(rest, count - 1, idx + 1);
-                (),
-            },
-        },
-    }
-  }
-
-  -- The first `n_params` args of the spine must be exactly
-  -- `BVar(n_fields + n_params - 1 - i)` for i in 0..n_params, i.e. the
-  -- de Bruijn references to the param binders peeled off the ctor's
-  -- type. The remaining args are the indices — those are unrestricted
-  -- here (per Rust 2046+).
-  fn assert_first_args_are_param_bvars(args: List‹KExpr›,
-                                        n_params: G, n_fields: G, i: G) {
-    -- `n_params` is the TOTAL param count (constant across recursion);
-    -- iterate i = 0..n_params. Expected j = (n_fields + n_params) - 1 - i
-    -- where i is the param index from outermost, so arg[0] points at the
-    -- outermost binder (highest BVar) and arg[n_params-1] at the innermost.
-    match n_params - i {
-      0 => (),
-      _ =>
-        match load(args) {
-          ListNode.Cons(arg, rest) =>
-            match load(arg) {
-              KExprNode.BVar(j) =>
-                assert_eq!(j, ((n_fields + n_params) - 1) - i);
-                assert_first_args_are_param_bvars(rest, n_params, n_fields, i + 1);
-                (),
-            },
-        },
-    }
-  }
-
-  -- Extract the inductive's result-sort level: peel `n` (params + indices)
-  -- Foralls; the body must be `Srt(level)`. Returns the level value.
-  -- Mirror: src/ix/kernel/inductive.rs::get_result_sort_level (line 2101+):
-  -- whnf BEFORE each peel and before the final Sort match — index binders
-  -- can hide under definitional wrappers (e.g. Mathlib's
-  -- `inductive εClosure (S : Set σ) : Set σ` stores a type ending in
-  -- `Set σ`, which only whnf exposes as `σ → Prop`).
-  fn get_result_sort_level(ind_ty: KExpr, n: G,
-                           types: List‹KExpr›,
-                           top: List‹&KConstantInfo›,
-                           addrs: List‹Addr›) -> KLevel {
-    let w = whnf(ind_ty, types, top, addrs);
-    match n {
-      0 =>
-        match load(w) {
-          KExprNode.Srt(l) => l,
-        },
-      _ =>
-        match load(w) {
-          KExprNode.Forall(dom, body) =>
-            get_result_sort_level(body, n - 1,
-                                  store(ListNode.Cons(dom, types)), top, addrs),
-        },
-    }
-  }
-
-  -- Mirror: src/ix/kernel/inductive.rs:1917-1965 check_field_universes.
-  -- Each ctor field's domain universe must be ≤ the inductive's
-  -- result universe. Skipped for Prop (Sort 0) per Rust line 1924.
-  --
-  -- Walks the ctor type past `n_params` Foralls (param binders),
-  -- threading the binder types into `types`. Then on each remaining
-  -- Forall (a field), ensures `dom`'s sort level is ≤ ind_level via
-  -- `k_ensure_sort` + `level_leq`.
-  fn check_field_universes(ctor_ty: KExpr, n_params: G, ind_level: KLevel,
-                           types: List‹KExpr›,
-                           top: List‹&KConstantInfo›, addrs: List‹Addr›) {
-    -- Skip if inductive is Prop.
-    match load(ind_level) {
-      KLevelNode.Zero => (),
-      _ => check_field_universes_skip_params(ctor_ty, n_params, ind_level, types, top, addrs),
-    }
-  }
-
-  fn check_field_universes_skip_params(ctor_ty: KExpr, n_params: G, ind_level: KLevel,
-                                        types: List‹KExpr›,
-                                        top: List‹&KConstantInfo›, addrs: List‹Addr›) {
-    match n_params {
-      0 => check_field_universes_inner(ctor_ty, ind_level, types, top, addrs),
-      _ =>
-        match load(ctor_ty) {
-          KExprNode.Forall(dom, body) =>
-            let types2 = store(ListNode.Cons(dom, types));
-            check_field_universes_skip_params(body, n_params - 1, ind_level, types2, top, addrs),
-        },
-    }
-  }
-
-  fn check_field_universes_inner(ty: KExpr, ind_level: KLevel,
-                                  types: List‹KExpr›,
-                                  top: List‹&KConstantInfo›, addrs: List‹Addr›) {
-    match load(ty) {
-      KExprNode.Forall(dom, body) =>
-        let dom_level = k_ensure_sort(dom, types, top, addrs);
-        let ok = level_leq(dom_level, ind_level);
-        assert_eq!(ok, 1);
-        let types2 = store(ListNode.Cons(dom, types));
-        check_field_universes_inner(body, ind_level, types2, top, addrs),
-      _ => (),
-    }
-  }
-
-  -- Mirror: src/ix/kernel/inductive.rs:1702-1830 check_positivity.
-  -- Strict positivity: each ctor field's domain must not have any inductive
-  -- of `ind_idx`'s mutual block in a negative position (left of an arrow).
-  --
-  -- For mutual blocks, the initial positivity context is the full set of
-  -- peer inductive idxs (derived via block_addr). Nested inductives are
-  -- handled by augment_block_idxs walking ctor bodies recursively.
-  fn check_positivity(ctor_ty: KExpr, n_params: G, ind_idx: G,
-                      types: List‹KExpr›,
-                      top: List‹&KConstantInfo›, addrs: List‹Addr›) {
-    let pair = peel_n_foralls_with_types(ctor_ty, n_params, types);
-    match pair {
-      (body, types_after) =>
-        let block_idxs = derive_block_member_idxs(ind_idx, top);
-        check_positivity_fields(body, block_idxs, types_after, top, addrs),
-    }
-  }
-
-  fn peel_n_foralls_tolerant(e: KExpr, n: G) -> KExpr {
-    match n {
-      0 => e,
-      _ =>
-        match load(e) {
-          KExprNode.Forall(_, body) => peel_n_foralls_tolerant(body, n - 1),
-          _ => e,
-        },
-    }
-  }
-
-  -- Like `peel_n_foralls_tolerant` but accumulates each binder's domain into
-  -- the types context so subsequent WHNF calls have the right local context.
-  fn peel_n_foralls_with_types(e: KExpr, n: G, types: List‹KExpr›) -> (KExpr, List‹KExpr›) {
-    match n {
-      0 => (e, types),
-      _ =>
-        match load(e) {
-          KExprNode.Forall(dom, body) =>
-            let types2 = store(ListNode.Cons(dom, types));
-            peel_n_foralls_with_types(body, n - 1, types2),
-          _ => (e, types),
-        },
-    }
-  }
-
-  fn check_positivity_fields(ty: KExpr, block_idxs: List‹G›,
-                             types: List‹KExpr›,
-                             top: List‹&KConstantInfo›, addrs: List‹Addr›) {
-    match load(ty) {
-      KExprNode.Forall(dom, body) =>
-        check_positivity_aug(dom, block_idxs, types, top, addrs);
-        let types2 = store(ListNode.Cons(dom, types));
-        check_positivity_fields(body, block_idxs, types2, top, addrs),
-      _ => (),
-    }
-  }
-
-  -- Mirror src/ix/kernel/inductive.rs:1741-1850. WHNF `dom` first so that
-  -- ctor-field types written via reducible defs (e.g. `constType (n α) (n α)`,
-  -- `id Sort`) collapse to their underlying inductive head before we
-  -- classify them as block / nested / non-inductive.
-  fn check_positivity_aug(dom: KExpr, block_idxs: List‹G›,
-                           types: List‹KExpr›,
-                           top: List‹&KConstantInfo›, addrs: List‹Addr›) {
-    match expr_mentions_any_idx(dom, block_idxs) {
-      0 => (),
-      _ =>
-        let dom_w = whnf(dom, types, top, addrs);
-        match load(dom_w) {
-          KExprNode.Forall(inner_dom, inner_body) =>
-            assert_eq!(expr_mentions_any_idx(inner_dom, block_idxs), 0);
-            let types2 = store(ListNode.Cons(inner_dom, types));
-            check_positivity_aug(inner_body, block_idxs, types2, top, addrs),
-          _ =>
-            match collect_spine(dom_w) {
-              (head, args) =>
-                match load(head) {
-                  KExprNode.Const(idx, _) =>
-                    match list_contains_g(block_idxs, idx) {
-                      1 => (),
-                      0 =>
-                        -- Nested: idx must be an Inductive in top. Mirror
-                        -- src/ix/kernel/inductive.rs:1781-1784: anything
-                        -- else (Defn/Thm/Axio/etc.) is "not a valid
-                        -- inductive app".
-                        let ci = load(list_lookup(top, idx));
-                        match ci {
-                          KConstantInfo.Induct(_, _, n_params, _, ctor_indices, _, ext_block_addr) =>
-                            let after_params = list_drop(args, n_params);
-                            assert_eq!(list_any_mentions(after_params, block_idxs), 0);
-                            let aug = augment_block_idxs(block_idxs, ext_block_addr, top);
-                            check_ctors_positivity(ctor_indices, args, aug, top, addrs),
-                          _ =>
-                            assert_eq!(0, 1);
-                            (),
-                        },
-                    },
-                  _ =>
-                    assert_eq!(0, 1);
-                    (),
-                },
-            },
-        },
-    }
-  }
-
-  fn list_contains_g(xs: List‹G›, target: G) -> G {
-    match load(xs) {
-      ListNode.Nil => 0,
-      ListNode.Cons(x, rest) =>
-        match x - target {
-          0 => 1,
-          _ => list_contains_g(rest, target),
-        },
-    }
-  }
-
-  -- Mirror: src/ix/kernel/inductive.rs fn computed_is_rec. Ixon no longer
-  -- stores the recr flag; is_rec is computed on demand from constructor
-  -- structure. Aiur memoization is the is_rec_cache (keyed on induct_idx);
-  -- no cycle-breaking needed because `compute_is_rec` is structural (no
-  -- whnf), unlike the Rust version.
-  fn computed_is_rec_ind(induct_idx: G, top: List‹&KConstantInfo›) -> G {
-    let ci = load(list_lookup(top, induct_idx));
-    match ci {
-      KConstantInfo.Induct(_, _, n_params, _, ctor_indices, _, _) =>
-        let block_idxs = derive_block_member_idxs(induct_idx, top);
-        compute_is_rec(ctor_indices, n_params, block_idxs, top),
-      _ => 0,
-    }
-  }
-
-  -- Mirror: src/ix/kernel/inductive.rs fn compute_is_rec.
-  -- Compute is_rec by scanning each ctor's field domains (post n_params
-  -- peeling) for any reference to a block member's idx.
-  -- Returns 1 iff at least one field domain mentions a block_idx.
-  fn compute_is_rec(ctors: List‹G›, n_params: G, block_idxs: List‹G›,
-                    top: List‹&KConstantInfo›) -> G {
-    match load(ctors) {
-      ListNode.Nil => 0,
-      ListNode.Cons(ctor_idx, rest) =>
-        let ctor_ci = load(list_lookup(top, ctor_idx));
-        match ctor_ci {
-          KConstantInfo.Ctor(_, ctor_ty, _, _, _, _, _) =>
-            let after_params = peel_n_foralls_tolerant(ctor_ty, n_params);
-            match scan_fields_for_block_ref(after_params, block_idxs) {
-              1 => 1,
-              0 => compute_is_rec(rest, n_params, block_idxs, top),
-            },
-          _ => compute_is_rec(rest, n_params, block_idxs, top),
-        },
-    }
-  }
-
-  fn scan_fields_for_block_ref(ty: KExpr, block_idxs: List‹G›) -> G {
-    match load(ty) {
-      KExprNode.Forall(dom, body) =>
-        match expr_mentions_any_idx(dom, block_idxs) {
-          1 => 1,
-          0 => scan_fields_for_block_ref(body, block_idxs),
-        },
-      _ => 0,
-    }
-  }
-
-  fn expr_mentions_any_idx(e: KExpr, idxs: List‹G›) -> G {
-    match load(e) {
-      KExprNode.BVar(_) => 0,
-      KExprNode.Srt(_) => 0,
-      KExprNode.Const(idx, _) => list_contains_g(idxs, idx),
-      KExprNode.App(f, a) =>
-        let fm = expr_mentions_any_idx(f, idxs);
-        match fm {
-          1 => 1,
-          0 => expr_mentions_any_idx(a, idxs),
-        },
-      KExprNode.Lam(t, b) =>
-        let tm = expr_mentions_any_idx(t, idxs);
-        match tm {
-          1 => 1,
-          0 => expr_mentions_any_idx(b, idxs),
-        },
-      KExprNode.Forall(t, b) =>
-        let tm = expr_mentions_any_idx(t, idxs);
-        match tm {
-          1 => 1,
-          0 => expr_mentions_any_idx(b, idxs),
-        },
-      KExprNode.Let(t, v, b) =>
-        let tm = expr_mentions_any_idx(t, idxs);
-        match tm {
-          1 => 1,
-          0 =>
-            let vm = expr_mentions_any_idx(v, idxs);
-            match vm {
-              1 => 1,
-              0 => expr_mentions_any_idx(b, idxs),
-            },
-        },
-      KExprNode.Lit(_) => 0,
-      KExprNode.Proj(_, _, e1) => expr_mentions_any_idx(e1, idxs),
-    }
-  }
-
-  fn list_any_mentions(es: List‹KExpr›, idxs: List‹G›) -> G {
-    match load(es) {
-      ListNode.Nil => 0,
-      ListNode.Cons(e, rest) =>
-        let m = expr_mentions_any_idx(e, idxs);
-        match m {
-          1 => 1,
-          0 => list_any_mentions(rest, idxs),
-        },
-    }
-  }
-
-  -- Augment block_idxs with the indices of all Inducts in `top` that share
-  -- `ext_block_addr` (so the ext Induct's own block becomes part of the
-  -- positivity context).
-  fn augment_block_idxs(block_idxs: List‹G›, ext_block_addr: Addr,
-                         top: List‹&KConstantInfo›) -> List‹G› {
-    augment_walk(block_idxs, ext_block_addr, top, 0)
-  }
-
-  fn augment_walk(block_idxs: List‹G›, ext_block_addr: Addr,
-                   consts: List‹&KConstantInfo›, idx: G) -> List‹G› {
-    match load(consts) {
-      ListNode.Nil => block_idxs,
-      ListNode.Cons(&ci, rest) =>
-        match ci {
-          KConstantInfo.Induct(_, _, _, _, _, _, ba) =>
-            let same = address_eq(ba, ext_block_addr);
-            let nonzero = 1 - address_eq(ext_block_addr, store([0u8; 32]));
-            let already = list_contains_g(block_idxs, idx);
-            let add = same * nonzero * (1 - already);
-            match add {
-              1 =>
-                let new_idxs = store(ListNode.Cons(idx, block_idxs));
-                augment_walk(new_idxs, ext_block_addr, rest, idx + 1),
-              0 =>
-                augment_walk(block_idxs, ext_block_addr, rest, idx + 1),
-            },
-          _ =>
-            augment_walk(block_idxs, ext_block_addr, rest, idx + 1),
-        },
-    }
-  }
-
-  -- Walk ext inductive's ctors. For each, apply substituted-positivity check
-  -- on field types via `check_positivity_aug`. Param substitution is implicit
-  -- — ext ctors reference params via BVar; we treat ext's params as lifted
-  -- block_idxs since the nested ext fields can mention any of those.
-  -- Simplification: walk ctor body fields directly; their refs to ext
-  -- params correspond positionally to args[0..n_params] which are checked
-  -- transitively when augmented. Sound for direct nested cases.
-  fn check_ctors_positivity(ctor_indices: List‹G›, args: List‹KExpr›,
-                            aug: List‹G›, top: List‹&KConstantInfo›,
-                            addrs: List‹Addr›) {
-    match load(ctor_indices) {
-      ListNode.Nil => (),
-      ListNode.Cons(ctor_idx, rest) =>
-        let ctor_ci = load(list_lookup(top, ctor_idx));
-        match ctor_ci {
-          KConstantInfo.Ctor(_, ctor_ty, _, _, n_params, _, _) =>
-            let pair = peel_n_foralls_with_types(ctor_ty, n_params, store(ListNode.Nil));
-            match pair {
-              (body, types_after) =>
-                check_positivity_fields_aug(body, aug, types_after, top, addrs);
-                check_ctors_positivity(rest, args, aug, top, addrs),
-            },
-          _ => check_ctors_positivity(rest, args, aug, top, addrs),
-        },
-    }
-  }
-
-  fn check_positivity_fields_aug(ty: KExpr, aug: List‹G›,
-                                  types: List‹KExpr›,
-                                  top: List‹&KConstantInfo›, addrs: List‹Addr›) {
-    match load(ty) {
-      KExprNode.Forall(dom, body) =>
-        check_positivity_aug(dom, aug, types, top, addrs);
-        let types2 = store(ListNode.Cons(dom, types));
-        check_positivity_fields_aug(body, aug, types2, top, addrs),
-      _ => (),
-    }
-  }
-
-  -- Returns 1 if `e` contains any Const(ind_idx, _), 0 otherwise.
-  fn expr_mentions_idx(e: KExpr, ind_idx: G) -> G {
-    match load(e) {
-      KExprNode.BVar(_) => 0,
-      KExprNode.Srt(_) => 0,
-      KExprNode.Const(idx, _) =>
-        match idx - ind_idx {
-          0 => 1,
-          _ => 0,
-        },
-      KExprNode.App(f, a) =>
-        g_or(expr_mentions_idx(f, ind_idx), expr_mentions_idx(a, ind_idx)),
-      KExprNode.Lam(t, b) =>
-        g_or(expr_mentions_idx(t, ind_idx), expr_mentions_idx(b, ind_idx)),
-      KExprNode.Forall(t, b) =>
-        g_or(expr_mentions_idx(t, ind_idx), expr_mentions_idx(b, ind_idx)),
-      KExprNode.Let(t, v, b) =>
-        g_or(expr_mentions_idx(t, ind_idx),
-             g_or(expr_mentions_idx(v, ind_idx), expr_mentions_idx(b, ind_idx))),
-      KExprNode.Lit(_) => 0,
-      KExprNode.Proj(_, _, e1) => expr_mentions_idx(e1, ind_idx),
-    }
-  }
-
-  -- ============================================================================
-  -- Canonical recursor type generation (solo / mutual / nested-aux)
-  --
-  -- Mirror: src/ix/kernel/inductive.rs::build_motive_type_flat (line 2475+).
-  -- For non-aux members (is_aux=0): peel own_params with BVar refs to
-  -- recursor's outer params. For aux members (is_aux=1): substitute first
-  -- |spec_params| with the concrete spec_params lifted to the current depth.
-  -- n_rec_params is the block-shared param count; univ_offset is 0 for
-  -- Prop-targeting inductives, 1 for large eliminators (motive output univ
-  -- added at position 0).
-  -- ============================================================================
-
-  -- Build motive type:
-  --   forall (i_0 : I_0_ty) ... (i_M : I_M_ty),
-  --   forall (major : Indc.{occurrence_us} params indices),
-  --   Sort elim_level
-  --
-  -- Where:
-  --   * params come from peeling n_params Foralls off ind_ty, substituting
-  --     each binder with BVar(n_rec_params - 1 - j) (recursor outer-scope
-  --     param refs);
-  --   * occurrence_us = [Param(univ_offset), ..., Param(univ_offset + ind_lvls - 1)];
-  --   * elim_level is Param(0) for large eliminators, Zero for Prop.
-  -- Mirror: src/ix/kernel/inductive.rs:2128-2205 is_large_eliminator.
-  -- Returns 1 if recursor for this Indc can target any universe (i.e.
-  -- gets a motive output univ param), 0 if must target Prop.
-  --
-  -- Cases (mirrors lean4lean):
-  --   1. Result level non-zero → always large.
-  --   2. Result is Prop AND 0 ctors (Empty/False) → large.
-  --   3. Result is Prop AND single ctor AND 0 fields → large.
-  --   4. Result is Prop AND single ctor AND all fields are Prop-typed
-  --      → large (subsingleton). Covers And/Eq/Acc/Iff/etc.
-  --      (Approximation of Rust's full check: all non-trivial fields
-  --      must appear in return args; conservative when some field is
-  --      Type-typed since we then return 0 = not large.)
-  --   5. Otherwise (multiple ctors in Prop) → not large.
-  fn is_large_eliminator(result_level: KLevel,
-                         ctor_indices: List‹G›,
-                         top: List‹&KConstantInfo›,
-                         addrs: List‹Addr›) -> G {
-    let nz = level_is_not_zero(result_level);
-    match nz {
-      1 => 1,
-      0 =>
-        let n_ctors = list_length(ctor_indices);
-        match n_ctors {
-          0 => 1,
-          1 =>
-            let ctor_idx = list_lookup(ctor_indices, 0);
-            let ctor_ci = load(list_lookup(top, ctor_idx));
-            match ctor_ci {
-              KConstantInfo.Ctor(_, ctor_ty, _, _, n_params, n_fields, _) =>
-                match n_fields {
-                  0 => 1,
-                  _ =>
-                    check_large_prop_ctor(ctor_ty, n_params, n_fields,
-                                          store(ListNode.Nil), top, addrs),
-                },
-            },
-          _ => 0,
-        },
-    }
-  }
-
-  -- Mirror: src/ix/kernel/inductive.rs:2148-2200 large-elim check on Prop
-  -- single-ctor inductive. Walk past `n_params` Foralls (skipping params),
-  -- then walk `n_fields` Foralls collecting de Bruijn indices of data fields
-  -- (those whose domain has sort != 0). Body after walk is the ctor's return
-  -- type; check each data field's BVar appears in the return-type's spine
-  -- args. If all do → large eliminator.
-  fn check_large_prop_ctor(ty: KExpr, n_params: G, n_fields: G,
-                           types: List‹KExpr›, top: List‹&KConstantInfo›,
-                           addrs: List‹Addr›) -> G {
-    match n_params {
-      0 =>
-        check_large_walk_fields(ty, n_fields, 0, types, top, addrs,
-                                store(ListNode.Nil)),
-      _ =>
-        match load(ty) {
-          KExprNode.Forall(dom, body) =>
-            let inner = store(ListNode.Cons(dom, types));
-            check_large_prop_ctor(body, n_params - 1, n_fields, inner, top, addrs),
-          _ => 0,
-        },
-    }
-  }
-
-  -- Walk `n_fields` Foralls, threading list of data-field BVars (de Bruijn
-  -- indices in the post-walk ret context). After walk, collect ret spine
-  -- args and verify every data BVar appears.
-  fn check_large_walk_fields(ty: KExpr, n_fields: G, field_idx: G,
-                              types: List‹KExpr›, top: List‹&KConstantInfo›,
-                              addrs: List‹Addr›,
-                              data_bvars: List‹G›) -> G {
-    match n_fields - field_idx {
-      0 =>
-        match collect_spine(ty) {
-          (_, args) => all_bvars_in_args(data_bvars, args),
-        },
-      _ =>
-        match load(ty) {
-          KExprNode.Forall(dom, body) =>
-            let lvl = k_ensure_sort(dom, types, top, addrs);
-            let is_data = 1 - level_equal(lvl, store(KLevelNode.Zero));
-            let bvar_idx = n_fields - 1 - field_idx;
-            let new_bvars = match is_data {
-              0 => data_bvars,
-              _ => store(ListNode.Cons(bvar_idx, data_bvars)),
-            };
-            let inner = store(ListNode.Cons(dom, types));
-            check_large_walk_fields(body, n_fields, field_idx + 1, inner, top, addrs,
-                                     new_bvars),
-          _ => 0,
-        },
-    }
-  }
-
-  -- Returns 1 iff every BVar idx in `bvars` appears in `args` (as a syntactic
-  -- BVar at the ret-binder depth).
-  fn all_bvars_in_args(bvars: List‹G›, args: List‹KExpr›) -> G {
-    match load(bvars) {
-      ListNode.Nil => 1,
-      ListNode.Cons(b, rest) =>
-        match args_contain_bvar(args, b) {
-          0 => 0,
-          1 => all_bvars_in_args(rest, args),
-        },
-    }
-  }
-
-  -- Returns 1 if any element of `args` is syntactically `BVar(target)`.
-  fn args_contain_bvar(args: List‹KExpr›, target: G) -> G {
-    match load(args) {
-      ListNode.Nil => 0,
-      ListNode.Cons(a, rest) =>
-        match load(a) {
-          KExprNode.BVar(i) =>
-            match i - target {
-              0 => 1,
-              _ => args_contain_bvar(rest, target),
-            },
-          _ => args_contain_bvar(rest, target),
-        },
-    }
-  }
-
-  -- Build motive type for a flat block member.
-  -- is_aux=0 (original): peel n_own_params subst with BVar(n_rec_params-1-j).
-  -- is_aux=1 (aux for nested ext): peel ext.n_params; substitute first
-  --   spec_params.len() with spec_params[j] (lifted to current depth=0,
-  --   which equals identity when spec_params live in recursor-param frame),
-  --   the rest with BVar(n_rec_params-1-j).
-  -- Major: aux applies spec_params lifted by n_indices; non-aux applies
-  -- recursor-param BVars.
-  fn build_motive_type_flat(ind_idx: G, ind_ty: KExpr,
-                            n_own_params: G, n_indices: G,
-                            occurrence_us: List‹KLevel›,
-                            elim_level: KLevel,
-                            n_rec_params: G,
-                            is_aux: G, spec_params: List‹KExpr›,
-                            top: List‹&KConstantInfo›,
-                            addrs: List‹Addr›) -> KExpr {
-    let ind_ty_inst = expr_inst_levels(ind_ty, occurrence_us);
-    let after_params = peel_motive_params_subst(ind_ty_inst, n_own_params, n_rec_params,
-                                          is_aux, spec_params, 0);
-    let index_doms = collect_index_doms(after_params, n_indices, top, addrs);
-    let head = store(KExprNode.Const(ind_idx, occurrence_us));
-    let with_args = build_major_args_for_member(head, n_rec_params, n_indices,
-                                                 is_aux, spec_params);
-    let major_ty = build_major_indices(with_args, n_indices, 0);
-    let sort_e = store(KExprNode.Srt(elim_level));
-    let with_major = store(KExprNode.Forall(major_ty, sort_e));
-    wrap_foralls(with_major, index_doms)
-  }
-
-  -- For aux: apply spec_params (each lifted by depth=n_indices) to head.
-  -- For non-aux: apply n_rec_params recursor-param BVars to head.
-  fn build_major_args_for_member(head: KExpr, n_rec_params: G, depth: G,
-                                  is_aux: G, spec_params: List‹KExpr›) -> KExpr {
-    match is_aux {
-      0 => build_major_params(head, n_rec_params, depth, 0),
-      _ => apply_spec_params_lifted(head, spec_params, depth),
-    }
-  }
-
-  fn apply_spec_params_lifted(head: KExpr, spec_params: List‹KExpr›,
-                              depth: G) -> KExpr {
-    match load(spec_params) {
-      ListNode.Nil => head,
-      ListNode.Cons(sp, rest) =>
-        let lifted = expr_lift(sp, depth, 0);
-        apply_spec_params_lifted(store(KExprNode.App(head, lifted)), rest, depth),
-    }
-  }
-
-  -- Peel n Foralls; for each binder j substitute per is_aux:
-  --   non-aux: BVar(n_rec_params - 1 - j).
-  --   aux: spec_params[j] when j < |spec_params|, else BVar(n_rec_params - 1 - j).
-  fn peel_motive_params_subst(ty: KExpr, n: G, n_rec_params: G,
-                        is_aux: G, spec_params: List‹KExpr›, j: G) -> KExpr {
-    match n {
-      0 => ty,
-      _ =>
-        match load(ty) {
-          KExprNode.Forall(_, body) =>
-            let p = subst_param_for(j, n_rec_params, is_aux, spec_params);
-            let body_substed = expr_inst1(body, p, 0);
-            peel_motive_params_subst(body_substed, n - 1, n_rec_params,
-                              is_aux, spec_params, j + 1),
-        },
-    }
-  }
-
-  fn subst_param_for(j: G, n_rec_params: G, is_aux: G,
-                      spec_params: List‹KExpr›) -> KExpr {
-    match is_aux {
-      0 => store(KExprNode.BVar((n_rec_params - 1) - j)),
-      _ =>
-        let len = list_length(spec_params);
-        let lt = u32_less_than(j, len);
-        match lt {
-          1 => list_lookup(spec_params, j),
-          _ => store(KExprNode.BVar((n_rec_params - 1) - j)),
-        },
-    }
-  }
-
-  -- Peel ctor's leading own_params. Non-aux: plain peel. Aux: substitute
-  -- each with spec_params[j] (or BVar fallback if beyond spec).
-  fn peel_rule_ctor_params(ty: KExpr, n: G,
-                            is_aux: G, spec_params: List‹KExpr›) -> KExpr {
-    match is_aux {
-      0 => peel_n_foralls(ty, n),
-      -- Rule-rhs field doms stay in the natural ctor-body scope (params
-      -- directly above): spec_lift = 0, later frame moves happen at the
-      -- use sites via list_lift_indices.
-      _ => peel_ctor_params_subst(ty, n, 0, 0, 1, spec_params, 0),
-    }
-  }
-
-  -- Look up Ctor.num_params from top.
-  fn ctor_num_params_of(ctor_idx: G, top: List‹&KConstantInfo›) -> G {
-    let ci = load(list_lookup(top, ctor_idx));
-    match ci {
-      KConstantInfo.Ctor(_, _, _, _, num_params, _, _) => num_params,
-      _ => 0,
-    }
-  }
-
-  -- Peel ctor's own_params with depth-aware substitution. For non-aux:
-  -- BVar(depth-1-j). For aux: spec_params[j] lifted by `spec_lift`
-  -- (binders between the recursor-param frame and the peel point — NOT
-  -- `depth`, which counts the params themselves too) when j < |spec|;
-  -- BVar(depth-1-j) otherwise.
-  fn peel_ctor_params_subst(ty: KExpr, n: G, depth: G, spec_lift: G,
-                             is_aux: G, spec_params: List‹KExpr›, j: G) -> KExpr {
-    match n {
-      0 => ty,
-      _ =>
-        match load(ty) {
-          KExprNode.Forall(_, body) =>
-            let p = ctor_subst_param_for(j, depth, spec_lift, is_aux, spec_params);
-            let body_substed = expr_inst1(body, p, 0);
-            peel_ctor_params_subst(body_substed, n - 1, depth, spec_lift,
-                                    is_aux, spec_params, j + 1),
-        },
-    }
-  }
-
-  fn ctor_subst_param_for(j: G, depth: G, spec_lift: G, is_aux: G,
-                           spec_params: List‹KExpr›) -> KExpr {
-    match is_aux {
-      0 => store(KExprNode.BVar((depth - 1) - j)),
-      _ =>
-        let len = list_length(spec_params);
-        let lt = u32_less_than(j, len);
-        match lt {
-          1 =>
-            let sp = list_lookup(spec_params, j);
-            expr_lift(sp, spec_lift, 0),
-          _ => store(KExprNode.BVar((depth - 1) - j)),
-        },
-    }
-  }
-
-  -- Mirror: src/ix/kernel/inductive.rs:2521-2531 — whnf before each peel.
-  -- Index binders can hide under definitional wrappers (e.g. a result type
-  -- `Set σ` only exposes its `σ → Prop` index binder after whnf).
-  fn collect_index_doms(ty: KExpr, n: G,
-                        top: List‹&KConstantInfo›,
-                        addrs: List‹Addr›) -> List‹KExpr› {
-    match n {
-      0 => store(ListNode.Nil),
-      _ =>
-        let w = whnf(ty, store(ListNode.Nil), top, addrs);
-        match load(w) {
-          KExprNode.Forall(dom, body) =>
-            store(ListNode.Cons(dom, collect_index_doms(body, n - 1, top, addrs))),
-        },
-    }
-  }
-
-  -- [Param(start), Param(start+1), ..., Param(start+count-1)] as List‹KLevel›.
-  fn build_param_lvls_range(start: G, count: G, i: G) -> List‹KLevel› {
-    match count - i {
-      0 => store(ListNode.Nil),
-      _ =>
-        store(ListNode.Cons(
-          store(KLevelNode.Param(start + i)),
-          build_param_lvls_range(start, count, i + 1))),
-    }
-  }
-
-  -- Apply head to recursor params: `App(... App(head, BVar(n_rec_params-1+depth)), ...)`.
-  -- Each param j is at BVar(n_rec_params - 1 - j + depth) where depth is
-  -- the index-binder count above the major position.
-  fn build_major_params(head: KExpr, n_rec_params: G, depth: G, j: G) -> KExpr {
-    match n_rec_params - j {
-      0 => head,
-      _ =>
-        let v = store(KExprNode.BVar(((n_rec_params - 1) - j) + depth));
-        build_major_params(store(KExprNode.App(head, v)), n_rec_params, depth, j + 1),
-    }
-  }
-
-  -- Apply head to indices: `App(... App(head, BVar(n_indices-1)), ...)`.
-  -- Index i (0-indexed from outermost) is BVar(n_indices - 1 - i) at the
-  -- major's scope.
-  fn build_major_indices(head: KExpr, n_indices: G, i: G) -> KExpr {
-    match n_indices - i {
-      0 => head,
-      _ =>
-        let v = store(KExprNode.BVar((n_indices - 1) - i));
-        build_major_indices(store(KExprNode.App(head, v)), n_indices, i + 1),
-    }
-  }
-
-  -- Wrap body in foralls outside-in: doms = [d0, d1, ..., dM] →
-  -- `forall (_ : d0), forall (_ : d1), ..., forall (_ : dM), body`.
-  fn wrap_foralls(body: KExpr, doms: List‹KExpr›) -> KExpr {
-    match load(doms) {
-      ListNode.Nil => body,
-      ListNode.Cons(dom, rest) =>
-        store(KExprNode.Forall(dom, wrap_foralls(body, rest))),
-    }
-  }
-
-  -- ============================================================================
-  -- build_minor_at_depth (flat-aware: solo / mutual / nested-aux)
-  --
-  -- Mirror: src/ix/kernel/inductive.rs:2596-2806.
-  -- Builds the minor binder type for a single ctor, including IHs for
-  -- recursive fields. Forall-wrapped recursive fields (e.g.
-  -- `(Nat → Foo) → Foo`) are handled via `is_rec_field` peeling leading
-  -- foralls + `build_ih_doms` wrapping IH body in matching foralls.
-  -- For aux ctors (is_aux=1): peel ext.n_params with spec_params subst.
-  -- Motive offset = `motive_base + self_mem_idx` for the owning member.
-  -- ============================================================================
-  -- `self_mem_idx` = this member's POSITION in flat (not resolved from
-  -- ind_idx: two aux entries can share the same base const idx with
-  -- different spec_params, and an idx lookup would alias the second
-  -- member's motive to the first's).
-  fn build_minor_at_depth(ind_idx: G, ctor_idx: G, ctor_ty: KExpr,
-                          is_aux: G, spec_params: List‹KExpr›,
-                          occurrence_us: List‹KLevel›,
-                          flat: List‹(G, G, List‹KExpr›, List‹KLevel›)›,
-                          flat_idxs: List‹G›,
-                          flat_own_params: List‹G›,
-                          n_rec_params: G, n_motives: G, prev_minors: G,
-                          motive_base: G, self_mem_idx: G,
-                          top: List‹&KConstantInfo›, addrs: List‹Addr›) -> KExpr {
-    let ctor_ty_inst = expr_inst_levels(ctor_ty, occurrence_us);
-    let minor_saved = n_rec_params + n_motives + prev_minors;
-    -- Peel ctor's own_params. For non-aux: n_own_params == n_rec_params, all
-    -- substitute with BVar(minor_saved-1-j). For aux: n_own_params == ext.n_params;
-    -- first |spec_params| substitute with spec_params[j] lifted by
-    -- below_params, the rest with BVar(minor_saved-1-j).
-    let n_own_params = ctor_num_params_of(ctor_idx, top);
-    -- Binders between the recursor-param frame and this minor's start:
-    -- the motives and previous minors. Spec_params lift by this amount
-    -- (both when substituted into aux ctor params and when matched by
-    -- is_rec_field).
-    let below_params = n_motives + prev_minors;
-    let after_params = peel_ctor_params_subst(ctor_ty_inst, n_own_params,
-                                               minor_saved, below_params,
-                                               is_aux, spec_params, 0);
-    let walk = walk_fields_classify(after_params, flat, store(ListNode.Nil),
-                                     store(ListNode.Nil), store(ListNode.Nil),
-                                     store(ListNode.Nil), top, addrs, 0,
-                                     below_params);
-    match walk {
-      (field_doms, rec_indices, rec_member_idxs, ret_ty) =>
-        let n_fields = list_length(field_doms);
-        let n_ihs = list_length(rec_indices);
-        let n_binders = n_fields + n_ihs;
-        let depth_now = minor_saved + n_binders;
-        let ret_pair = collect_spine(ret_ty);
-        match ret_pair {
-          (_ret_head, ret_args) =>
-            -- Drop n_own_params from ret to expose indices.
-            let ret_indices = list_drop(ret_args, n_own_params);
-            let ret_indices_lifted = list_lift_each(ret_indices, n_ihs, 0);
-            let motive_var = (depth_now - 1) - (motive_base + self_mem_idx);
-            let motive_ref = store(KExprNode.BVar(motive_var));
-            let with_indices = apply_spine(motive_ref, ret_indices_lifted);
-            let ctor_head = store(KExprNode.Const(ctor_idx, occurrence_us));
-            -- For non-aux: apply n_rec_params recursor-param BVars.
-            -- For aux: apply spec_params lifted to body scope (depth_now-1+1 = depth_now).
-            let with_params = build_ctor_app_params(ctor_head, n_own_params,
-                                                     n_rec_params, depth_now,
-                                                     is_aux, spec_params);
-            let ctor_app = build_apply_field_bvars(with_params, n_fields, n_binders, 0);
-            let conclusion = store(KExprNode.App(with_indices, ctor_app));
-            let ih_doms = build_ih_doms(rec_indices, rec_member_idxs, field_doms,
-                                        flat_own_params, motive_base, n_fields,
-                                        minor_saved, store(ListNode.Nil), top, addrs, 0);
-            let with_ihs = wrap_foralls(conclusion, ih_doms);
-            wrap_foralls(with_ihs, field_doms),
-        },
-    }
-  }
-
-  -- Apply ctor head with its own_params. Non-aux: BVar refs to recursor
-  -- params (depth_now-1 down to depth_now-n_rec_params). Aux: spec_params
-  -- lifted from the recursor-param frame by the binders below the params
-  -- (depth_now counts the params themselves; subtract them).
-  fn build_ctor_app_params(head: KExpr, n_own_params: G, n_rec_params: G,
-                           depth_now: G,
-                           is_aux: G, spec_params: List‹KExpr›) -> KExpr {
-    match is_aux {
-      0 => build_apply_bvars_decreasing(head, n_rec_params, depth_now - 1, 0),
-      _ => apply_spec_params_lifted(head, spec_params, depth_now - n_rec_params),
-    }
-  }
-
-  -- Peel n Foralls; substitute each binder with `BVar(depth - 1 - j)`.
-  fn peel_n_subst_at_depth(ty: KExpr, n: G, depth: G, j: G) -> KExpr {
-    match n {
-      0 => ty,
-      _ =>
-        match load(ty) {
-          KExprNode.Forall(_, body) =>
-            let p = store(KExprNode.BVar((depth - 1) - j));
-            let body_substed = expr_inst1(body, p, 0);
-            peel_n_subst_at_depth(body_substed, n - 1, depth, j + 1),
-        },
-    }
-  }
-
-  -- Walk Foralls of `ty` collecting (field_doms, rec_field_indices, ret_ty).
-  -- A field is recursive (direct case) when its spine head is Const(ind_idx).
-  -- Builds accumulators with O(1) cons (prepend) and reverses once at end —
-  -- O(F) total vs O(F²) with snoc.
-  fn walk_fields_classify(ty: KExpr, flat: List‹(G, G, List‹KExpr›, List‹KLevel›)›,
-                          doms_acc: List‹KExpr›, rec_acc: List‹G›,
-                          rec_mem_acc: List‹G›,
-                          types: List‹KExpr›,
-                          top: List‹&KConstantInfo›, addrs: List‹Addr›,
-                          fidx: G, spec_lift_by: G)
-                          -> (List‹KExpr›, List‹G›, List‹G›, KExpr) {
-    match load(ty) {
-      KExprNode.Forall(dom, body) =>
-        let r = is_rec_field(dom, flat, types, top, addrs, spec_lift_by);
-        let new_doms = store(ListNode.Cons(dom, doms_acc));
-        let types2 = store(ListNode.Cons(dom, types));
-        match r {
-          (1, mem_idx) =>
-            let new_rec = store(ListNode.Cons(fidx, rec_acc));
-            let new_mem = store(ListNode.Cons(mem_idx, rec_mem_acc));
-            walk_fields_classify(body, flat, new_doms, new_rec, new_mem,
-                                 types2, top, addrs, fidx + 1, spec_lift_by),
-          _ =>
-            walk_fields_classify(body, flat, new_doms, rec_acc, rec_mem_acc,
-                                 types2, top, addrs, fidx + 1, spec_lift_by),
-        },
-      _ => (list_reverse(doms_acc), list_reverse(rec_acc), list_reverse(rec_mem_acc), ty),
-    }
-  }
-
-  -- Derive the list of block-member indices for a recursor's parent ind.
-  -- Solo (ind's block_addr = [0;32]) → `[ind_idx]`. Otherwise walks `top`
-  -- collecting all Inducts sharing the block_addr in positional order.
-  fn derive_block_member_idxs(ind_idx: G, top: List‹&KConstantInfo›) -> List‹G› {
-    let ci = load(list_lookup(top, ind_idx));
-    match ci {
-      KConstantInfo.Induct(_, _, _, _, _, _, block_addr) =>
-        match address_eq(block_addr, store([0u8; 32])) {
-          1 => store(ListNode.Cons(ind_idx, store(ListNode.Nil))),
-          0 =>
-            let table = block_members_table(top, 0);
-            let bucket = rbtree_map_lookup_or_default(addr_key(block_addr), table,
-                                                      store(ListNode.Nil));
-            block_bucket_find(bucket, block_addr),
-        },
-      _ => store(ListNode.Cons(ind_idx, store(ListNode.Nil))),
-    }
-  }
-
-  -- ============================================================================
-  -- Block-membership table: addr_key(block_addr) → bucket of
-  -- (block_addr, ascending Induct positions).
-  --
-  -- Every derive_block_member_idxs query used to rescan the whole `top`
-  -- list per block; each scan step's memo key included the block addr, so
-  -- N-const closures paid |blocks| × |top| query-map entries — the map
-  -- blew up to billions of entries on mathlib shards and hash ops ate the
-  -- entire run. This walk's memo keys are (tail, idx) only, so ALL blocks
-  -- share one O(|top|) pass; each query then costs one rbtree lookup.
-  --
-  -- addr_key truncates to 4 bytes, so distinct blocks can collide on a
-  -- key; buckets keep (full addr, members) pairs and block_bucket_find
-  -- confirms with address_eq — collisions cost a short bucket walk, never
-  -- a wrong member list (unlike the skip-set's benign-overwrite scheme).
-  -- ============================================================================
-  fn block_members_table(consts: List‹&KConstantInfo›, idx: G)
-      -> RBTreeMap‹List‹(Addr, List‹G›)›› {
-    match load(consts) {
-      ListNode.Nil => RBTreeMap.Nil,
-      ListNode.Cons(&ci, rest) =>
-        let table = block_members_table(rest, idx + 1);
-        match ci {
-          KConstantInfo.Induct(_, _, _, _, _, _, ba) =>
-            match address_eq(ba, store([0u8; 32])) {
-              1 => table,
-              -- Building bottom-up, `idx` is smaller than every position
-              -- already in the bucket: prepending keeps members ascending.
-              0 => block_table_add(table, ba, idx),
-            },
-          _ => table,
-        },
-    }
-  }
-
-  fn block_table_add(table: RBTreeMap‹List‹(Addr, List‹G›)››,
-                     ba: Addr, idx: G) -> RBTreeMap‹List‹(Addr, List‹G›)›› {
-    let key = addr_key(ba);
-    let bucket = rbtree_map_lookup_or_default(key, table, store(ListNode.Nil));
-    rbtree_map_insert(key, block_bucket_add(bucket, ba, idx), table)
-  }
-
-  fn block_bucket_add(bucket: List‹(Addr, List‹G›)›,
-                      ba: Addr, idx: G) -> List‹(Addr, List‹G›)› {
-    match load(bucket) {
-      ListNode.Nil =>
-        store(ListNode.Cons(
-          (ba, store(ListNode.Cons(idx, store(ListNode.Nil)))),
-          store(ListNode.Nil))),
-      ListNode.Cons(entry, rest) =>
-        match entry {
-          (eba, members) =>
-            match address_eq(eba, ba) {
-              1 => store(ListNode.Cons((eba, store(ListNode.Cons(idx, members))), rest)),
-              0 => store(ListNode.Cons(entry, block_bucket_add(rest, ba, idx))),
-            },
-        },
-    }
-  }
-
-  fn block_bucket_find(bucket: List‹(Addr, List‹G›)›, ba: Addr) -> List‹G› {
-    match load(bucket) {
-      ListNode.Nil => store(ListNode.Nil),
-      ListNode.Cons(entry, rest) =>
-        match entry {
-          (eba, members) =>
-            match address_eq(eba, ba) {
-              1 => members,
-              0 => block_bucket_find(rest, ba),
-            },
-        },
-    }
-  }
-
-  -- Returns 1 iff idx ≠ ind_idx but Inducts at idx and ind_idx share the
-  -- same non-[0;32] block_addr. Used to classify peer/aux refs in block
-  -- as recursive for IH building.
-  fn is_in_same_block(idx: G, ind_idx: G, top: List‹&KConstantInfo›) -> G {
-    let i_ci = load(list_lookup(top, ind_idx));
-    match i_ci {
-      KConstantInfo.Induct(_, _, _, _, _, _, ind_ba) =>
-        match address_eq(ind_ba, store([0u8; 32])) {
-          1 => 0,
-          0 =>
-            let other_ci = load(list_lookup(top, idx));
-            match other_ci {
-              KConstantInfo.Induct(_, _, _, _, _, _, other_ba) =>
-                address_eq(other_ba, ind_ba),
-              _ => 0,
-            },
-        },
-      _ => 0,
-    }
-  }
-
-  -- Mirror: src/ix/kernel/inductive.rs:2968-3019 fn is_rec_field.
-  -- Returns (is_rec, member_local_idx) where member_local_idx is the position
-  -- within `flat` of the matching entry (0 for direct member). Returns (0, 0)
-  -- if not recursive. WHNFs the per-field body so that ctor field types written
-  -- via reducible defs collapse to expose the underlying inductive head. The
-  -- match key is (head_const_idx, spine_arg_prefix ≡ flat.spec_params) — const
-  -- idx alone is not enough because a nested aux (e.g. `List Lean.Syntax`)
-  -- shares the base ind's idx with unrelated occurrences (e.g. `List
-  -- Preresolved`); using idx alone would false-positive the unrelated field
-  -- as recursive and inject a spurious IH binder.
-  -- `spec_lift_by` = binders between the recursor-param frame (where
-  -- flat spec_params live) and the start of the caller's field walk;
-  -- the field's own walk depth (`list_length(types)`) is added here.
-  -- Mirror: Rust's explicit `spec_params_lift_by` (inductive.rs:2972,
-  -- see the historical note there — guessing the lift from local depth
-  -- breaks one of build_minor_at_depth / build_rule_rhs).
-  fn is_rec_field(dom: KExpr, flat: List‹(G, G, List‹KExpr›, List‹KLevel›)›,
-                   types: List‹KExpr›, top: List‹&KConstantInfo›,
-                   addrs: List‹Addr›, spec_lift_by: G) -> (G, G) {
-    -- Mirror inductive.rs is_rec_field's loop: whnf, peel ONE Forall,
-    -- repeat — WITHOUT pushing the peeled binder doms into a whnf
-    -- context. The body's loose BVars (field locals and the caller
-    -- frame's param refs) are stuck under whnf either way, and a
-    -- context built from local doms violates ctx-trim's frame
-    -- well-formedness (a param-referencing dom's lbr exceeds the depth
-    -- below it, running ctx_next_cut off the end of the list —
-    -- e.g. a Prop class `C (pat) where f (s t) : P pat s → ...`).
-    -- Per-peel whnf also exposes index binders hidden under
-    -- definitional wrappers, which the old peel-then-whnf missed.
-    let lift = spec_lift_by + list_length(types);
-    is_rec_field_peel(dom, flat, lift, top, addrs)
-  }
-
-  fn is_rec_field_peel(ty: KExpr, flat: List‹(G, G, List‹KExpr›, List‹KLevel›)›,
-                       lift: G, top: List‹&KConstantInfo›,
-                       addrs: List‹Addr›) -> (G, G) {
-    let w = whnf(ty, store(ListNode.Nil), top, addrs);
-    match load(w) {
-      KExprNode.Forall(_, body) =>
-        is_rec_field_peel(body, flat, lift, top, addrs),
-      _ =>
-        match collect_spine(w) {
-          (head, spine_args) =>
-            match load(head) {
-              KExprNode.Const(idx, _) =>
-                find_flat_member_match(flat, idx, spine_args, 0, lift),
-              _ => (0, 0),
-            },
-        },
-    }
-  }
-
-  -- Walk `flat`; return (1, i) at the first entry whose idx == head_idx AND
-  -- whose spec_params structurally match the leading `|spec_params|` entries
-  -- of the field's spine args. Original members have spec_params=[] so any
-  -- field whose head is the original ind matches. Auxes carry their concrete
-  -- occurrence, so only fields applied to that exact occurrence match.
-  fn find_flat_member_match(flat: List‹(G, G, List‹KExpr›, List‹KLevel›)›,
-                             head_idx: G, spine_args: List‹KExpr›,
-                             i: G, spec_lift_by: G) -> (G, G) {
-    match load(flat) {
-      ListNode.Nil => (0, 0),
-      ListNode.Cons(entry, rest) =>
-        match entry {
-          (fidx, _, fsps, _) =>
-            match fidx - head_idx {
-              0 =>
-                match spine_prefix_eq(spine_args, fsps, spec_lift_by) {
-                  1 => (1, i),
-                  _ => find_flat_member_match(rest, head_idx, spine_args, i + 1,
-                                              spec_lift_by),
-                },
-              _ => find_flat_member_match(rest, head_idx, spine_args, i + 1,
-                                          spec_lift_by),
-            },
-        },
-    }
-  }
-
-  -- Structural prefix compare: 1 iff `spec_params` (lifted from the
-  -- recursor-param frame to the caller's depth) is a prefix of
-  -- `spine_args` under `kexpr_struct_eq`. Empty spec_params always
-  -- matches.
-  fn spine_prefix_eq(spine_args: List‹KExpr›, spec_params: List‹KExpr›,
-                     spec_lift_by: G) -> G {
-    match load(spec_params) {
-      ListNode.Nil => 1,
-      ListNode.Cons(sp, sps_rest) =>
-        match load(spine_args) {
-          ListNode.Nil => 0,
-          ListNode.Cons(sa, sa_rest) =>
-            match kexpr_struct_eq(sa, expr_lift(sp, spec_lift_by, 0)) {
-              1 => spine_prefix_eq(sa_rest, sps_rest, spec_lift_by),
-              _ => 0,
-            },
-        },
-    }
-  }
-
-  -- Find target's index within block_member_idxs. (1, idx) if found else (0, 0).
-  fn find_member_local_idx(idxs: List‹G›, target: G, i: G) -> (G, G) {
-    match load(idxs) {
-      ListNode.Nil => (0, 0),
-      ListNode.Cons(x, rest) =>
-        match x - target {
-          0 => (1, i),
-          _ => find_member_local_idx(rest, target, i + 1),
-        },
-    }
-  }
-
-  fn peel_leading_foralls(ty: KExpr) -> (List‹KExpr›, KExpr) {
-    let pair = peel_leading_foralls_acc(ty, store(ListNode.Nil));
-    match pair {
-      (rev_acc, body) => (list_reverse(rev_acc), body),
-    }
-  }
-
-  -- Builds doms in reverse via O(1) cons; caller reverses once.
-  fn peel_leading_foralls_acc(ty: KExpr, acc: List‹KExpr›) -> (List‹KExpr›, KExpr) {
-    match load(ty) {
-      KExprNode.Forall(dom, body) =>
-        peel_leading_foralls_acc(body, store(ListNode.Cons(dom, acc))),
-      _ => (acc, ty),
-    }
-  }
-
-  -- Apply head to xs from outermost: x_0 = BVar(n_xs - 1), ..., x_{n-1} = BVar(0).
-  fn build_apply_xs(head: KExpr, n_xs: G, i: G) -> KExpr {
-    match n_xs - i {
-      0 => head,
-      _ =>
-        let v = store(KExprNode.BVar((n_xs - 1) - i));
-        build_apply_xs(store(KExprNode.App(head, v)), n_xs, i + 1),
-    }
-  }
-
-  fn list_lift_each(es: List‹KExpr›, shift: G, cutoff: G) -> List‹KExpr› {
-    match load(es) {
-      ListNode.Nil => store(ListNode.Nil),
-      ListNode.Cons(e, rest) =>
-        store(ListNode.Cons(expr_lift(e, shift, cutoff),
-                            list_lift_each(rest, shift, cutoff))),
-    }
-  }
-
-  -- Apply head to BVars at descending positions: `App(... App(head, BVar(start)), BVar(start-1)), ...`
-  -- Used for ctor params (BVar refs to recursor's outer params at depth_now).
-  fn build_apply_bvars_decreasing(head: KExpr, n: G, start: G, j: G) -> KExpr {
-    match n - j {
-      0 => head,
-      _ =>
-        let v = store(KExprNode.BVar(start - j));
-        build_apply_bvars_decreasing(store(KExprNode.App(head, v)), n, start, j + 1),
-    }
-  }
-
-  -- Apply head to ctor fields: `App(... App(head, BVar(n_binders-1)), BVar(n_binders-2)), ...`
-  fn build_apply_field_bvars(head: KExpr, n_fields: G, n_binders: G, i: G) -> KExpr {
-    match n_fields - i {
-      0 => head,
-      _ =>
-        let v = store(KExprNode.BVar((n_binders - 1) - i));
-        build_apply_field_bvars(store(KExprNode.App(head, v)), n_fields, n_binders, i + 1),
-    }
-  }
-
-  -- For each (rec_field_idx, k) pair, build IH dom:
-  -- `motive (lifted_idx_args) field_var`
-  -- at scope where fields are bound but k IHs already pushed.
-  --   depth_at_this_ih = minor_saved + n_fields + k
-  --   motive_var = depth_at_this_ih - 1 - motive_base
-  --   field_var  = depth_at_this_ih - 1 - (minor_saved + field_idx)
-  -- Lift the field's dom by (n_fields - field_idx + k) so its BVars
-  -- map into current scope. Then strip first n_rec_params spine args.
-  -- Collect first n Forall doms; return (doms, remaining_body).
-  fn collect_n_doms(ty: KExpr, n: G) -> (List‹KExpr›, KExpr) {
-    let pair = collect_n_doms_acc(ty, n, store(ListNode.Nil));
-    match pair {
-      (rev_acc, body) => (list_reverse(rev_acc), body),
-    }
-  }
-
-  fn collect_n_doms_acc(ty: KExpr, n: G, acc: List‹KExpr›) -> (List‹KExpr›, KExpr) {
-    match n {
-      0 => (acc, ty),
-      _ =>
-        match load(ty) {
-          KExprNode.Forall(dom, body) =>
-            collect_n_doms_acc(body, n - 1, store(ListNode.Cons(dom, acc))),
-        },
-    }
-  }
-
-  -- Apply head to indices in conclusion scope.
-  -- Index i (0-indexed from outer) at BVar(n_indices - i).
-  fn apply_indices_in_conclusion(head: KExpr, n_indices: G, i: G) -> KExpr {
-    match n_indices - i {
-      0 => head,
-      _ =>
-        let v = store(KExprNode.BVar(n_indices - i));
-        apply_indices_in_conclusion(store(KExprNode.App(head, v)), n_indices, i + 1),
-    }
-  }
-
-  -- Build per-ctor minor type list. is_aux + spec_params + occ_us control
-  -- how the ctor's leading own_params are substituted and what occurrence_us
-  -- to use for the ctor head; flat_idxs is used for rec field detection.
-  fn build_minor_doms(ctor_indices: List‹G›, ind_idx: G,
-                      is_aux: G, spec_params: List‹KExpr›,
-                      occurrence_us: List‹KLevel›,
-                      flat: List‹(G, G, List‹KExpr›, List‹KLevel›)›,
-                      flat_idxs: List‹G›,
-                      flat_own_params: List‹G›,
-                      n_rec_params: G, n_motives: G,
-                      motive_base: G, self_mem_idx: G,
-                      top: List‹&KConstantInfo›, addrs: List‹Addr›,
-                      prev_minors: G) -> List‹KExpr› {
-    match load(ctor_indices) {
-      ListNode.Nil => store(ListNode.Nil),
-      ListNode.Cons(ctor_idx, rest) =>
-        let ctor_ci = load(list_lookup(top, ctor_idx));
-        match ctor_ci {
-          KConstantInfo.Ctor(_, ctor_ty, _, _, _, _, _) =>
-            let minor = build_minor_at_depth(ind_idx, ctor_idx, ctor_ty,
-                                             is_aux, spec_params, occurrence_us,
-                                             flat, flat_idxs, flat_own_params,
-                                             n_rec_params, n_motives, prev_minors,
-                                             motive_base, self_mem_idx, top, addrs);
-            let rest_minors = build_minor_doms(rest, ind_idx, is_aux, spec_params,
-                                               occurrence_us, flat, flat_idxs,
-                                               flat_own_params,
-                                               n_rec_params, n_motives,
-                                               motive_base, self_mem_idx,
-                                               top, addrs, prev_minors + 1);
-            store(ListNode.Cons(minor, rest_minors)),
-        },
-    }
-  }
-
-  -- Build motive types for every flat block member. Each member's motive_ty
-  -- references shared params (BVar 0..n_rec_params-1) and its own n_indices,
-  -- with elim_level + univ_offset shared. Motive j (j>0) lifted by j to
-  -- account for the j prior motives bound between params and motive j
-  -- (mirror src/ix/kernel/inductive.rs:3074-3082).
-  fn build_all_motives(flat: List‹(G, G, List‹KExpr›, List‹KLevel›)›,
-                       n_params: G,
-                       ind_lvls: G, elim_level: KLevel, univ_offset: G,
-                       n_rec_params: G,
-                       top: List‹&KConstantInfo›,
-                       addrs: List‹Addr›) -> List‹KExpr› {
-    build_all_motives_walk(flat, n_params, ind_lvls, elim_level,
-                            univ_offset, n_rec_params, top, addrs, 0)
-  }
-
-  fn build_all_motives_walk(flat: List‹(G, G, List‹KExpr›, List‹KLevel›)›,
-                             n_params: G,
-                             ind_lvls: G, elim_level: KLevel, univ_offset: G,
-                             n_rec_params: G,
-                             top: List‹&KConstantInfo›,
-                             addrs: List‹Addr›, j: G) -> List‹KExpr› {
-    match load(flat) {
-      ListNode.Nil => store(ListNode.Nil),
-      ListNode.Cons(m, rest) =>
-        match m {
-          (member_idx, is_aux, spec_params, occ_us) =>
-            let ci = load(list_lookup(top, member_idx));
-            match ci {
-              KConstantInfo.Induct(_, m_ind_ty, m_own_params, m_n_indices, _, _, _) =>
-                let mt = build_motive_type_flat(member_idx, m_ind_ty, m_own_params,
-                                                 m_n_indices, occ_us, elim_level,
-                                                 n_rec_params,
-                                                 is_aux, spec_params, top, addrs);
-                let mt_lifted = expr_lift(mt, j, 0);
-                store(ListNode.Cons(mt_lifted,
-                  build_all_motives_walk(rest, n_params, ind_lvls, elim_level,
-                                          univ_offset, n_rec_params, top, addrs, j + 1))),
-              _ =>
-                build_all_motives_walk(rest, n_params, ind_lvls, elim_level,
-                                        univ_offset, n_rec_params, top, addrs, j),
-            },
-        },
-    }
-  }
-
-  -- Aggregate minor types across all flat block members' ctors. prev_minors
-  -- is the count of minors already added from previous members; threaded
-  -- through so each minor's depth math is correct. flat carries (ind_idx,
-  -- is_aux, spec_params) so aux ctors can substitute spec_params during
-  -- their own-param peel.
-  fn build_all_minors(flat: List‹(G, G, List‹KExpr›, List‹KLevel›)›,
-                      flat_idxs: List‹G›, flat_own_params: List‹G›,
-                      n_rec_params: G, n_motives: G,
-                      ind_lvls: G, univ_offset: G, motive_base: G,
-                      top: List‹&KConstantInfo›, addrs: List‹Addr›,
-                      prev_minors: G) -> List‹KExpr› {
-    build_all_minors_walk(flat, flat, flat_idxs, flat_own_params,
-                          n_rec_params, n_motives, ind_lvls, univ_offset,
-                          motive_base, top, addrs, prev_minors, 0)
-  }
-
-  -- `full_flat` stays pinned to the caller's original flat list so
-  -- `is_rec_field` sees every block member for spec_params matching; `flat`
-  -- shrinks as we iterate members. Bug guarded against: previously we passed
-  -- the shrinking `flat` into `build_minor_doms`, which made later members'
-  -- ctor-field classification blind to earlier members.
-  fn build_all_minors_walk(flat: List‹(G, G, List‹KExpr›, List‹KLevel›)›,
-                           full_flat: List‹(G, G, List‹KExpr›, List‹KLevel›)›,
-                           flat_idxs: List‹G›, flat_own_params: List‹G›,
-                           n_rec_params: G, n_motives: G,
-                           ind_lvls: G, univ_offset: G, motive_base: G,
-                           top: List‹&KConstantInfo›, addrs: List‹Addr›,
-                           prev_minors: G, mem_pos: G) -> List‹KExpr› {
-    match load(flat) {
-      ListNode.Nil => store(ListNode.Nil),
-      ListNode.Cons(m, rest) =>
-        match m {
-          (member_idx, is_aux, spec_params, occ_us) =>
-            let ci = load(list_lookup(top, member_idx));
-            match ci {
-              KConstantInfo.Induct(_, _, _, _, m_ctor_indices, _, _) =>
-                let m_minors = build_minor_doms(m_ctor_indices, member_idx,
-                                                 is_aux, spec_params, occ_us,
-                                                 full_flat, flat_idxs,
-                                                 flat_own_params,
-                                                 n_rec_params, n_motives,
-                                                 motive_base, mem_pos,
-                                                 top, addrs, prev_minors);
-                let added = list_length(m_minors);
-                let rest_minors = build_all_minors_walk(rest, full_flat,
-                                                    flat_idxs, flat_own_params,
-                                                    n_rec_params,
-                                                    n_motives, ind_lvls, univ_offset,
-                                                    motive_base, top, addrs,
-                                                    prev_minors + added, mem_pos + 1);
-                list_concat(m_minors, rest_minors),
-              _ =>
-                build_all_minors_walk(rest, full_flat,
-                                  flat_idxs, flat_own_params,
-                                  n_rec_params, n_motives, ind_lvls,
-                                  univ_offset, motive_base, top, addrs, prev_minors,
-                                  mem_pos + 1),
-            },
-        },
-    }
-  }
-
-  -- ============================================================================
-  -- build_rec_type (flat-aware: solo / mutual / nested-aux)
-  --
-  -- Mirror: src/ix/kernel/inductive.rs:3027+ build_rec_type.
-  -- Assembles full recursor type:
-  --
-  --   forall (params...),
-  --   forall (motive_0 : motive_ty_0) ... forall (motive_{N-1} : motive_ty_{N-1}),
-  --   forall (minor_0) ... forall (minor_{M-1}),
-  --   forall (indices...),
-  --   forall (major : Indc params indices),
-  --   motive_self indices major
-  --
-  -- N motives = |flat| (one per original + nested-aux block member).
-  -- M minors = sum of |ctors| across all flat members.
-  -- Computes elim_level / univ_offset internally via is_large_eliminator.
-  -- `primary_ind_idx` is the canonical block's source for `flat`; `ind_idx`
-  -- is self (= primary for solo/mutual; aux ext for nested aux recursors).
-  -- ============================================================================
-  -- `self_mem_pos` = self's POSITION in the flat block (signature-
-  -- resolved by the caller); idx lookup would alias same-idx aux
-  -- members.
-  -- whnf-tolerant n-binder collector (mirror the Rust param peel):
-  -- whnf before each peel so binders hidden under definitional wrappers
-  -- expose, and stop without failing when the type runs out of Foralls.
-  fn collect_n_doms_whnf(ty: KExpr, n: G, top: List‹&KConstantInfo›,
-                         addrs: List‹Addr›) -> (List‹KExpr›, KExpr) {
-    match n {
-      0 => (store(ListNode.Nil), ty),
-      _ =>
-        let w = whnf(ty, store(ListNode.Nil), top, addrs);
-        match load(w) {
-          KExprNode.Forall(dom, body) =>
-            match collect_n_doms_whnf(body, n - 1, top, addrs) {
-              (rest_doms, rest) =>
-                (store(ListNode.Cons(dom, rest_doms)), rest),
-            },
-          _ => (store(ListNode.Nil), w),
-        },
-    }
-  }
-
-  fn build_rec_type(ind_idx: G, ind_ty: KExpr, ctor_indices: List‹G›,
-                    n_params: G, n_indices: G, ind_lvls: G,
-                    self_own_params: G,
-                    primary_ind_idx: G, self_mem_pos: G,
-                    top: List‹&KConstantInfo›, addrs: List‹Addr›) -> KExpr {
-    let result_level = get_result_sort_level(ind_ty, self_own_params + n_indices,
-                                             store(ListNode.Nil), top, addrs);
-    let is_large = is_large_eliminator(result_level, ctor_indices, top, addrs);
-    let elim_level = match is_large {
-      1 => store(KLevelNode.Param(0)),
-      0 => store(KLevelNode.Zero),
-    };
-    let univ_offset = is_large;
-    let block_member_idxs = derive_block_member_idxs(primary_ind_idx, top);
-    let flat = build_flat_block(block_member_idxs, univ_offset, top, addrs);
-    let flat_idxs = flat_ind_idxs(flat);
-    let n_motives = list_length(flat);
-    let n_rec_params = n_params;
-    let motive_base = n_rec_params;
-
-    -- Params walk over the PRIMARY inductive's type under the first
-    -- inductive's univ_offset-shifted params, with a whnf-tolerant peel
-    -- (mirror inductive.rs build_rec_type: `ind_infos[0].4` +
-    -- `first_ind_univs`, whnf per step, break on non-Forall). Peeling
-    -- SELF's type with the primary's param count walks past the end for
-    -- aux-member recursors whose ext types have fewer binders.
-    let primary_ci0 = load(list_lookup(top, primary_ind_idx));
-    let params_walk = match primary_ci0 {
-      KConstantInfo.Induct(p_lvls, p_ty, _, _, _, _, _) =>
-        let p_us = build_param_lvls_range(univ_offset, p_lvls, 0);
-        collect_n_doms_whnf(expr_inst_levels(p_ty, p_us), n_params, top, addrs),
-      _ =>
-        collect_n_doms_whnf(ind_ty, n_params, top, addrs),
-    };
-    match params_walk {
-      (param_doms, after_params) =>
-        let flat_own_params = flat_own_params_of(flat, top);
-        let motive_doms = build_all_motives(flat, n_params,
-                                             ind_lvls, elim_level, univ_offset,
-                                             n_rec_params, top, addrs);
-
-        let minor_doms = build_all_minors(flat, flat_idxs, flat_own_params,
-                                           n_rec_params, n_motives,
-                                           ind_lvls, univ_offset, motive_base, top, addrs, 0);
-        let n_minors = list_length(minor_doms);
-
-        -- whnf-aware: index binders can hide under definitional wrappers
-        -- (mirror inductive.rs build_rec_type's whnf-peel index walk).
-        let index_doms_raw = collect_index_doms(after_params, n_indices, top, addrs);
-        let index_doms = list_lift_indices(index_doms_raw, n_motives + n_minors, 0);
-        let self_mem_idx = self_mem_pos;
-        let self_member = flat_member_at(flat, self_mem_idx);
-        let self_is_aux = match self_member { (_, ia, _, _) => ia, };
-        let self_spec_params = match self_member { (_, _, sp, _) => sp, };
-        let self_occ_us = match self_member { (_, _, _, ou) => ou, };
-        let head = store(KExprNode.Const(ind_idx, self_occ_us));
-        let pre_major_depth = n_rec_params + n_motives + n_minors + n_indices;
-        let with_args = build_major_args_for_self(head, n_rec_params,
-                                                   pre_major_depth - 1,
-                                                   n_motives + n_minors + n_indices,
-                                                   self_is_aux, self_spec_params);
-        let major_ty = build_major_indices(with_args, n_indices, 0);
-
-        let depth_after_major = pre_major_depth + 1;
-        let motive_var = (depth_after_major - 1) - (motive_base + self_mem_idx);
-        let motive_ref = store(KExprNode.BVar(motive_var));
-        let with_indices = apply_indices_in_conclusion(motive_ref, n_indices, 0);
-        let conclusion = store(KExprNode.App(with_indices, store(KExprNode.BVar(0))));
-
-        let with_major = store(KExprNode.Forall(major_ty, conclusion));
-        let with_idx_foralls = wrap_foralls(with_major, index_doms);
-        let with_minors = wrap_foralls(with_idx_foralls, minor_doms);
-        let with_motives = wrap_foralls(with_minors, motive_doms);
-        wrap_foralls(with_motives, param_doms),
-    }
-  }
-
-  -- ============================================================================
-  -- build_rule_rhs (flat-aware: solo / mutual / nested-aux, direct case)
-  --
-  -- Mirror: src/ix/kernel/inductive.rs:3571+ build_rule_rhs.
-  -- Builds the RHS of the recursor rule for one ctor:
-  --
-  --   λ (params...) λ (motives...) λ (minors...) λ (fields...),
-  --   minor_i field_0 ... field_{F-1} IH_0 ... IH_R
-  --
-  -- Where IH_j (direct case for rec field of target member t) =
-  --   Const(peer_recs[t], lvls) (params) (motives) (minors) (idx_args) field_j
-  --
-  -- For aux ctors (is_aux=1): peel ext.n_params with spec_params subst so
-  -- field doms become concrete. For non-aux mutual: peer_recs maps each
-  -- block member to its own recursor. No post-major args.
-  -- ============================================================================
-  fn build_rule_rhs(rec_idx: G, ind_idx: G, ctor_idx: G, ctor_ty: KExpr,
-                    ctor_minor_index: G,
-                    n_params: G, n_motives: G, n_minors: G,
-                    ind_lvls: G, univ_offset: G,
-                    motive_doms: List‹KExpr›, minor_doms: List‹KExpr›,
-                    param_doms: List‹KExpr›, peer_recs: List‹G›,
-                    flat: List‹(G, G, List‹KExpr›, List‹KLevel›)›,
-                    flat_idxs: List‹G›, flat_own_params: List‹G›,
-                    is_aux: G, spec_params: List‹KExpr›,
-                    occurrence_us: List‹KLevel›,
-                    top: List‹&KConstantInfo›, addrs: List‹Addr›) -> KExpr {
-    let rec_lvls_list = build_rec_lvls(ind_lvls + univ_offset, 0);
-    let ctor_ty_inst = expr_inst_levels(ctor_ty, occurrence_us);
-    -- Peel n_params Foralls without substitution. Field doms collected
-    -- by walk live in their natural ctor-body scope: at walk position i,
-    -- peer fields 0..i-1 occupy BVar(0..i-1) (stack: latest peer at
-    -- BVar(0)) and params occupy BVar(i..i+n_params-1) (auto-shifted by
-    -- de Bruijn semantics as walk descends Foralls). Lifts to Lam-type
-    -- and body scopes happen at use sites.
-    -- Peel ctor's own_params. Non-aux: leave as natural BVars (caller lifts
-    -- via list_lift_indices). Aux: substitute with spec_params so field doms
-    -- become concrete; at this point, depth=0, fields will be lifted later.
-    let n_own_params = ctor_num_params_of(ctor_idx, top);
-    let after_params = peel_rule_ctor_params(ctor_ty_inst, n_own_params,
-                                              is_aux, spec_params);
-    -- Natural ctor-body scope: params sit directly above the walk, so
-    -- the spec_params base lift is 0 (only the walk depth applies).
-    let walk = walk_fields_classify(after_params, flat, store(ListNode.Nil),
-                                     store(ListNode.Nil), store(ListNode.Nil),
-                                     store(ListNode.Nil), top, addrs, 0, 0);
-    match walk {
-      (field_doms, rec_indices, rec_member_idxs, _ret_ty) =>
-        let n_fields = list_length(field_doms);
-        let n_ihs = list_length(rec_indices);
-        -- Body scope: all Lams pushed. depth = n_params + n_motives + n_minors + n_fields.
-        let body_depth = n_params + n_motives + n_minors + n_fields;
-        -- minor_i at BVar(body_depth - 1 - (n_params + n_motives + ctor_minor_index))
-        let minor_var = (body_depth - 1) - (n_params + n_motives + ctor_minor_index);
-        let minor_ref = store(KExprNode.BVar(minor_var));
-        -- Apply ctor fields: field j at BVar(n_fields - 1 - j)
-        let with_fields = build_apply_field_bvars(minor_ref, n_fields, n_fields, 0);
-        -- Apply IHs: for each rec field j, build IH using peer_recs[mem_idx]
-        let body = apply_ihs(with_fields, rec_indices, rec_member_idxs, field_doms,
-                             peer_recs, flat_own_params,
-                             n_params, n_motives, n_minors, n_fields,
-                             rec_lvls_list, store(ListNode.Nil), top, addrs, 0);
-        -- Lift each field_dom (in walk-pos i scope) into its Lam-type
-        -- scope: peer refs (BVar < walk_pos i) stay; param refs
-        -- (BVar >= i) lift by n_motives + n_minors (= the additional
-        -- binders between params and field-Lams in rule-rhs).
-        let field_doms_for_lams = list_lift_indices(field_doms, n_motives + n_minors, 0);
-        let with_field_lams = wrap_lams(body, field_doms_for_lams);
-        -- Wrap with minor Lams (innermost first, but our minor_doms is outermost first)
-        let with_minor_lams = wrap_lams(with_field_lams, minor_doms);
-        -- Wrap with N motive Lams (one per block member; multi-member mutual)
-        let with_motive_lams = wrap_lams(with_minor_lams, motive_doms);
-        -- Wrap with param Lams
-        wrap_lams(with_motive_lams, param_doms),
-    }
-  }
-
-  -- Recursor's univ params: [Param(0), ..., Param(total_lvls-1)].
-  fn build_rec_lvls(total: G, i: G) -> List‹KLevel› {
-    match total - i {
-      0 => store(ListNode.Nil),
-      _ =>
-        store(ListNode.Cons(
-          store(KLevelNode.Param(i)),
-          build_rec_lvls(total, i + 1))),
-    }
-  }
-
-  fn wrap_lams(body: KExpr, doms: List‹KExpr›) -> KExpr {
-    match load(doms) {
-      ListNode.Nil => body,
-      ListNode.Cons(dom, rest) =>
-        store(KExprNode.Lam(dom, wrap_lams(body, rest))),
-    }
-  }
-
-  -- For each rec field j, append IH_j applied to `head`.
-  -- IH_j = `Const(target_rec, rec_lvls) (params...) (motives...) (minors...) (idx_args) field_j`.
-  -- target_rec = peer_recs[mem_idx] — the recursor for the field's own type.
-  -- Mirror: src/ix/kernel/inductive.rs:3838-3956 fn build_rule_ih.
-  -- Mirror src/ix/kernel/inductive.rs:3838-3956 fn build_rule_ih: WHNF the
-  -- field's lifted dom and the inner body so the head/args reflect the
-  -- true inductive occurrence (after reducing wrappers like
-  -- `constType (n α) (n α)` → `n α`).
-  fn apply_ihs(head: KExpr, rec_indices: List‹G›, rec_member_idxs: List‹G›,
-               field_doms: List‹KExpr›,
-               peer_recs: List‹G›, flat_own_params: List‹G›,
-               n_params: G, n_motives: G, n_minors: G, n_fields: G,
-               rec_lvls_list: List‹KLevel›, types: List‹KExpr›,
-               top: List‹&KConstantInfo›, addrs: List‹Addr›, k: G) -> KExpr {
-    match load(rec_indices) {
-      ListNode.Nil => head,
-      ListNode.Cons(field_idx, rest) =>
-        let mem_idx = list_lookup(rec_member_idxs, k);
-        let target_rec = list_lookup(peer_recs, mem_idx);
-        let target_n_params = list_lookup(flat_own_params, mem_idx);
-        let body_depth = n_params + n_motives + n_minors + n_fields;
-        let dom = list_lookup(field_doms, field_idx);
-        let dom_s1 = expr_lift(dom, n_fields - field_idx, 0);
-        let dom_lifted = expr_lift(dom_s1, n_motives + n_minors, n_fields);
-        let dom_w = whnf(dom_lifted, types, top, addrs);
-        match peel_leading_foralls(dom_w) {
-          (forall_doms, inner_body_raw) =>
-            let inner_types = list_concat(list_reverse(forall_doms), types);
-            let inner_body = whnf(inner_body_raw, inner_types, top, addrs);
-            let n_xs = list_length(forall_doms);
-            let inner_depth = body_depth + n_xs;
-            let rec_const = store(KExprNode.Const(target_rec, rec_lvls_list));
-            let with_params = build_apply_bvars_decreasing(rec_const, n_params, inner_depth - 1, 0);
-            let with_motives = build_apply_motives(with_params, n_motives,
-              ((inner_depth - 1) - n_params), 0);
-            let with_minors = build_apply_minors(with_motives, n_minors,
-              (((inner_depth - 1) - n_params) - n_motives), 0);
-            match collect_spine(inner_body) {
-              (_dh, dargs) =>
-                let idx_args = list_drop(dargs, target_n_params);
-                let with_idx = apply_spine(with_minors, idx_args);
-                let field_base = ((n_fields - 1) - field_idx) + n_xs;
-                let field_ref = store(KExprNode.BVar(field_base));
-                let field_app = build_apply_xs(field_ref, n_xs, 0);
-                let ih_inner = store(KExprNode.App(with_idx, field_app));
-                let ih = wrap_lams(ih_inner, forall_doms);
-                let new_head = store(KExprNode.App(head, ih));
-                apply_ihs(new_head, rest, rec_member_idxs, field_doms, peer_recs,
-                          flat_own_params, n_params, n_motives, n_minors, n_fields,
-                          rec_lvls_list, types, top, addrs, k + 1),
-            },
-        },
-    }
-  }
-
-  -- Apply n motives to `head`, each as BVar(start - i).
-  fn build_apply_motives(head: KExpr, n_motives: G, start: G, i: G) -> KExpr {
-    match n_motives - i {
-      0 => head,
-      _ =>
-        let v = store(KExprNode.BVar(start - i));
-        build_apply_motives(store(KExprNode.App(head, v)), n_motives, start, i + 1),
-    }
-  }
-
-  fn build_apply_minors(head: KExpr, n_minors: G, start: G, i: G) -> KExpr {
-    match n_minors - i {
-      0 => head,
-      _ =>
-        let v = store(KExprNode.BVar(start - i));
-        build_apply_minors(store(KExprNode.App(head, v)), n_minors, start, i + 1),
-    }
-  }
-
-  -- Generate all KRecRules for an Indc's ctors via build_rule_rhs.
-  -- Get the parent Indc's positional idx from a Recr's first rule.
-  -- For solo recursors, all rules dispatch on ctors of the same Indc.
-  -- Recursors with at least one rule: derive ind_idx via the rule's ctor.
-  -- Recursors with NO rules (inductives with 0 ctors, e.g. False.rec /
-  -- empty propositions): parse the recursor's type to extract the major's
-  -- head Const(ind_idx). Mirrors `get_major_inductive_id` in Rust.
-  fn rec_to_ind_idx_with_ty(rules: List‹KRecRule›, ty: KExpr,
-                             n_params: G, n_motives: G, n_minors: G,
-                             n_indices: G, top: List‹&KConstantInfo›) -> G {
-    -- Derive ind_idx from the recursor's typ ONLY (walk past
-    -- params+motives+minors+indices to reach `major`'s type, take its
-    -- head Const). The rule-path was unreliable: rule.ctor_idx points
-    -- to a Ctor whose own induct_idx was assigned at convert time using
-    -- `find_matching_block_addr` heuristic — when multiple in-scope
-    -- inductives share ctor count, that heuristic picks the wrong one.
-    -- Mirror: src/ix/kernel/inductive.rs::rec_to_ind_idx (typ-only path).
-    let skip = n_params + n_motives + n_minors + n_indices;
-    let after_skip = peel_n_foralls(ty, skip);
-    match load(after_skip) {
-      KExprNode.Forall(major_ty, _) =>
-        match collect_spine(major_ty) {
-          (head, _) =>
-            match load(head) {
-              KExprNode.Const(idx, _) => idx,
-            },
-        },
-    }
-  }
-
-  -- Extract a declared recursor type's spec signature: the major-premise
-  -- domain's leading `own` spine args, lowered from the major position
-  -- to the recursor-param frame. For a non-aux recursor these are the
-  -- recursor-param BVars themselves; for an aux recursor they equal the
-  -- flat member's stored spec_params (both interned, so ptr comparison
-  -- applies). Param args cannot reference index binders, so the lowering
-  -- is capture-free for well-formed types.
-  fn rec_declared_spec(ty: KExpr, n_p: G, n_mot: G, n_min: G, n_i: G,
-                       own: G) -> List‹KExpr› {
-    let pre_major = peel_n_foralls_tolerant(ty, ((n_p + n_mot) + n_min) + n_i);
-    match load(pre_major) {
-      KExprNode.Forall(major_dom, _) =>
-        match collect_spine(major_dom) {
-          (_head, args) =>
-            let param_args = list_take(args, own);
-            spec_params_lower(param_args, (n_mot + n_min) + n_i),
-        },
-      _ => store(ListNode.Nil),
-    }
-  }
-
-  -- Find the Rec idx in `top` whose major inductive is `target_ind_idx`.
-  -- Restricts to recursors with matching block_addr first (so aux Recs
-  -- in the same block resolve before sibling-namespace Recs of the same
-  -- external Indc), falling back to an unrestricted scan; returns 0
-  -- (never a valid Rec) if not found. `want_spec_check = 0` matches any
-  -- recursor whose major inductive is `target_ind_idx` (original
-  -- members: idx is unambiguous). With 1, additionally require the
-  -- declared spec signature to equal `target_sp` — aux recursors over
-  -- the same external inductive (rec_1/rec_2) differ only in their
-  -- spec_params.
-  fn find_rec_for_ind(target_ind_idx: G, want_spec_check: G,
-                      target_sp: List‹KExpr›, own: G, rec_block: Addr,
-                      top: List‹&KConstantInfo›) -> G {
-    let in_block = find_rec_for_ind_walk(target_ind_idx, want_spec_check,
-                                         target_sp, own, rec_block, 1, top, top, 0);
-    match in_block {
-      0 => find_rec_for_ind_walk(target_ind_idx, want_spec_check,
-                                 target_sp, own, rec_block, 0, top, top, 0),
-      _ => in_block,
-    }
-  }
-
-  fn find_rec_for_ind_walk(target_ind_idx: G, want_spec_check: G,
-                           target_sp: List‹KExpr›, own: G, rec_block: Addr,
-                           require_block: G,
-                           consts: List‹&KConstantInfo›,
-                           top: List‹&KConstantInfo›, idx: G) -> G {
-    match load(consts) {
-      ListNode.Nil => 0,
-      ListNode.Cons(&ci, rest) =>
-        match ci {
-          KConstantInfo.Rec(_, ty, n_p, n_i, n_m, n_min, rules, _, _, ba) =>
-            let rec_ind = rec_to_ind_idx_with_ty(rules, ty, n_p, n_m, n_min, n_i, top);
-            let ind_match = eq_zero(rec_ind - target_ind_idx);
-            let block_match = match require_block {
-              0 => 1,
-              _ => address_eq(ba, rec_block),
-            };
-            match ind_match * block_match {
-              1 =>
-                let spec_match = match want_spec_check {
-                  0 => 1,
-                  _ => spec_params_ptr_eq(
-                         rec_declared_spec(ty, n_p, n_m, n_min, n_i, own),
-                         target_sp),
-                };
-                match spec_match {
-                  1 => idx,
-                  0 => find_rec_for_ind_walk(target_ind_idx, want_spec_check,
-                                             target_sp, own, rec_block,
-                                             require_block, rest, top, idx + 1),
-                },
-              0 => find_rec_for_ind_walk(target_ind_idx, want_spec_check,
-                                         target_sp, own, rec_block,
-                                         require_block, rest, top, idx + 1),
-            },
-          _ => find_rec_for_ind_walk(target_ind_idx, want_spec_check,
-                                     target_sp, own, rec_block,
-                                     require_block, rest, top, idx + 1),
-        },
-    }
-  }
-
-  -- Build peer_recs[i] = rec_idx for flat[i], scoped to `rec_block`.
-  -- Aux members select by (idx, spec signature) — idx alone aliases
-  -- same-external-inductive auxes to the first peer recursor.
-  fn build_peer_recs(flat: List‹(G, G, List‹KExpr›, List‹KLevel›)›,
-                     rec_block: Addr,
-                     top: List‹&KConstantInfo›) -> List‹G› {
-    match load(flat) {
-      ListNode.Nil => store(ListNode.Nil),
-      ListNode.Cons(m, rest) =>
-        match m {
-          (member_idx, is_aux, sp, _ou) =>
-            let own = match load(list_lookup(top, member_idx)) {
-              KConstantInfo.Induct(_, _, np, _, _, _, _) => np,
-              _ => 0,
-            };
-            store(ListNode.Cons(
-              find_rec_for_ind(member_idx, is_aux, sp, own, rec_block, top),
-              build_peer_recs(rest, rec_block, top))),
-        },
-    }
-  }
-
-  fn rec_to_ind_idx(rules: List‹KRecRule›, top: List‹&KConstantInfo›) -> G {
-    match load(rules) {
-      ListNode.Cons(rule, _) =>
-        match rule {
-          KRecRule.Mk(ctor_idx, _, _) =>
-            let ctor_ci = load(list_lookup(top, ctor_idx));
-            match ctor_ci {
-              KConstantInfo.Ctor(_, _, induct_idx, _, _, _, _) => induct_idx,
-            },
-        },
-    }
-  }
-
-  -- Pairwise compare stored vs canonical KRecRule lists via k_is_def_eq.
-  fn list_lift_indices(doms: List‹KExpr›, lift: G, i: G) -> List‹KExpr› {
-    match load(doms) {
-      ListNode.Nil => store(ListNode.Nil),
-      ListNode.Cons(d, rest) =>
-        let lifted = expr_lift(d, lift, i);
-        store(ListNode.Cons(lifted, list_lift_indices(rest, lift, i + 1))),
-    }
-  }
-
-  fn compare_rules(stored: List‹KRecRule›, canonical: List‹KRecRule›,
-                   top: List‹&KConstantInfo›, addrs: List‹Addr›) {
-    match load(stored) {
-      ListNode.Nil =>
-        match load(canonical) {
-          ListNode.Nil => (),
-        },
-      ListNode.Cons(s, rs) =>
-        match load(canonical) {
-          ListNode.Cons(c, rc) =>
-            match s {
-              KRecRule.Mk(s_ctor, s_nf, s_rhs) =>
-                match c {
-                  KRecRule.Mk(c_ctor, c_nf, c_rhs) =>
-                    assert_eq!(s_ctor, c_ctor);
-                    assert_eq!(s_nf, c_nf);
-                    let eq = k_is_def_eq(s_rhs, c_rhs, store(ListNode.Nil), top, addrs);
-                    assert_eq!(eq, 1);
-                    compare_rules(rs, rc, top, addrs),
-                },
-            },
-        },
-    }
-  }
-
-  -- ============================================================================
-  -- check_recursor_member (flat-aware: solo / mutual / nested-aux).
-  --
-  -- Mirror: src/ix/kernel/inductive.rs::check_recursor_member.
-  -- For a stored Recr, regenerate canonical type + rules from the Indc
-  -- and compare via k_is_def_eq. Resolves the canonical block via
-  -- `resolve_primary_ind_for_rec` so aux recursors (e.g. Tree.rec_1) build
-  -- their canonical form against the original block (Tree's), not the
-  -- aux's external Indc block (List's).
-  -- ============================================================================
-  -- Mirror: src/ix/kernel/inductive.rs check_ctor_against_inductive_member.
-  -- Validates that the Ctor's (induct_idx, cidx) cross-references the
-  -- parent Indc's ctor_indices: `ctor_indices[cidx] == this_ctor_idx`.
-  fn check_ctor_against_inductive_member(ctor_idx: G, ci_ctor: KConstantInfo,
-                                          top: List‹&KConstantInfo›) {
-    match ci_ctor {
-      KConstantInfo.Ctor(_, _, induct_idx, cidx, _, _, _) =>
-        let ind_ci = load(list_lookup(top, induct_idx));
-        match ind_ci {
-          KConstantInfo.Induct(_, _, _, _, ctor_indices, _, _) =>
-            let expected = list_lookup(ctor_indices, cidx);
-            assert_eq!(expected, ctor_idx);
-            (),
-        },
-    }
-  }
-
-  -- Mirror: src/ix/kernel/inductive.rs:4451-4489 compute_k_target.
-  -- K-target valid iff: solo block, result level == 0 (Prop), single ctor
-  -- with zero non-param fields. Returns 1 if K-target, else 0.
-  fn compute_k_target(ind_idx: G, top: List‹&KConstantInfo›,
-                      addrs: List‹Addr›) -> G {
-    let ind_ci = load(list_lookup(top, ind_idx));
-    match ind_ci {
-      KConstantInfo.Induct(_, ind_ty, n_params, n_indices, ctor_indices, _, _) =>
-        let block_members = derive_block_member_idxs(ind_idx, top);
-        match list_length(block_members) - 1 {
-          0 =>
-            let result_level = get_result_sort_level(ind_ty, n_params + n_indices,
-                                                     store(ListNode.Nil), top, addrs);
-            match level_equal(result_level, store(KLevelNode.Zero)) {
-              0 => 0,
-              1 =>
-                match list_length(ctor_indices) - 1 {
-                  0 =>
-                    let ctor_idx = list_lookup(ctor_indices, 0);
-                    let ctor_ci = load(list_lookup(top, ctor_idx));
-                    match ctor_ci {
-                      KConstantInfo.Ctor(_, _, _, _, _, n_fields, _) => eq_zero(n_fields),
-                      _ => 0,
-                    },
-                  _ => 0,
-                },
-            },
-          _ => 0,
-        },
-      _ => 0,
-    }
-  }
-
-  -- Structural KExpr equality (heads + payload only; ignores universes/binder
-  -- names). Used to compare a ctor field's spine-arg prefix against a flat
-  -- aux member's spec_params in `is_rec_field`, where content-addressed exprs
-  -- from the same block-flattening pass are guaranteed to be structurally
-  -- comparable without WHNF.
-  fn kexpr_struct_eq(a: KExpr, b: KExpr) -> G {
-    match load(a) {
-      KExprNode.BVar(ia) =>
-        match load(b) {
-          KExprNode.BVar(ib) =>
-            match (u32_less_than(ia, ib) + u32_less_than(ib, ia)) {
-              0 => 1,
-              _ => 0,
-            },
-          _ => 0,
-        },
-      KExprNode.Srt(_) =>
-        match load(b) {
-          KExprNode.Srt(_) => 1,
-          _ => 0,
-        },
-      KExprNode.Const(ca, _) =>
-        match load(b) {
-          KExprNode.Const(cb, _) =>
-            match (u32_less_than(ca, cb) + u32_less_than(cb, ca)) {
-              0 => 1,
-              _ => 0,
-            },
-          _ => 0,
-        },
-      KExprNode.App(fa, aa) =>
-        match load(b) {
-          KExprNode.App(fb, ab) =>
-            let feq = kexpr_struct_eq(fa, fb);
-            match feq {
-              1 => kexpr_struct_eq(aa, ab),
-              _ => 0,
-            },
-          _ => 0,
-        },
-      KExprNode.Lam(ta, ba) =>
-        match load(b) {
-          KExprNode.Lam(tb, bb) =>
-            let teq = kexpr_struct_eq(ta, tb);
-            match teq {
-              1 => kexpr_struct_eq(ba, bb),
-              _ => 0,
-            },
-          _ => 0,
-        },
-      KExprNode.Forall(da, xa) =>
-        match load(b) {
-          KExprNode.Forall(db, xb) =>
-            let deq = kexpr_struct_eq(da, db);
-            match deq {
-              1 => kexpr_struct_eq(xa, xb),
-              _ => 0,
-            },
-          _ => 0,
-        },
-      _ => 0,
-    }
-  }
-
-  -- Resolve the declared recursor's flat-member POSITION. Aux recursors
-  -- over the same external inductive (rec_1/rec_2 with different
-  -- spec_params) share self_major's const idx, so an idx lookup aliases
-  -- them all to the first entry; disambiguate by the declared type's
-  -- major-premise domain: its spine's param args, lowered to the
-  -- recursor-param frame, must equal the flat member's stored
-  -- spec_params. Falls back to the first idx match (originals match on
-  -- idx alone — their spec_params are empty). A malformed declared type
-  -- only mis-selects a candidate; the declared-vs-canonical assert
-  -- still rejects. Mirror: the signature-based match in Rust
-  -- check_recursor_member (inductive.rs:4181-4219).
-  fn find_rec_self_pos(ty: KExpr, n_p: G, n_mot: G, n_min: G, n_i: G,
-                       self_major: G,
-                       flat: List‹(G, G, List‹KExpr›, List‹KLevel›)›,
-                       top: List‹&KConstantInfo›) -> G {
-    let self_ci = load(list_lookup(top, self_major));
-    match self_ci {
-      KConstantInfo.Induct(_, _, own, _, _, _, _) =>
-        let lowered = rec_declared_spec(ty, n_p, n_mot, n_min, n_i, own);
-        find_rec_self_pos_walk(flat, self_major, lowered, 0, 0),
-      _ => 0,
-    }
-  }
-
-  -- `first_any` = 1 + position of the first idx match seen (0 = none):
-  -- the fallback when no spec_params signature matches.
-  fn find_rec_self_pos_walk(flat: List‹(G, G, List‹KExpr›, List‹KLevel›)›,
-                            target_idx: G, largs: List‹KExpr›,
-                            i: G, first_any: G) -> G {
-    match load(flat) {
-      ListNode.Nil =>
-        match first_any {
-          0 => 0,
-          _ => first_any - 1,
-        },
-      ListNode.Cons(m, rest) =>
-        match m {
-          (fidx, is_aux, sp, _ou) =>
-            match (u32_less_than(fidx, target_idx) + u32_less_than(target_idx, fidx)) {
-              0 =>
-                let new_first = match first_any { 0 => i + 1, _ => first_any, };
-                match is_aux {
-                  0 => i,
-                  _ =>
-                    match spec_params_ptr_eq(sp, largs) {
-                      1 => i,
-                      0 => find_rec_self_pos_walk(rest, target_idx, largs,
-                                                  i + 1, new_first),
-                    },
-                },
-              _ => find_rec_self_pos_walk(rest, target_idx, largs, i + 1, first_any),
-            },
-        },
-    }
-  }
-
-  fn check_recursor_member(rec_idx: G, ci_rec: KConstantInfo,
-                           top: List‹&KConstantInfo›, addrs: List‹Addr›) {
-    match ci_rec {
-      KConstantInfo.Rec(_, ty, n_p, n_i, n_mot, n_min, rules, k_flag, _, rec_block) =>
-        -- For aux recursors (Tree.rec_1 etc), the "primary" inductive is the
-        -- one whose block carries the auxes — discoverable in the same rec_block.
-        -- Use it as the canonical-block source. Self's major may be different
-        -- (an external aux ind).
-        let self_major = rec_to_ind_idx_with_ty(rules, ty, n_p, n_mot, n_min, n_i, top);
-        -- Coherence gate: the major inductive must itself pass the
-        -- inductive checks before its recursor is validated — recursor
-        -- generation succeeds syntactically even when the inductive is
-        -- unsound. Mirror: crates/kernel/src/inductive.rs:4089-4102.
-        check_inductive_shape(self_major, top, addrs);
-        let ind_idx = resolve_primary_ind_for_rec(self_major, rec_block, top);
-        let computed_k = compute_k_target(self_major, top, addrs);
-        assert_eq!(k_flag, computed_k);
-        let primary_ci = load(list_lookup(top, ind_idx));
-        let self_ci = load(list_lookup(top, self_major));
-        match primary_ci {
-          KConstantInfo.Induct(ind_lvls, ind_ty, ind_n_params, _, _, _, _) =>
-            match self_ci {
-              KConstantInfo.Induct(_, self_ind_ty, self_own_params, self_n_indices, self_ctor_indices, _, _) =>
-                -- Re-derive elim_level / univ_offset using self's data.
-                let result_level = get_result_sort_level(self_ind_ty, self_own_params + self_n_indices,
-                                                         store(ListNode.Nil), top, addrs);
-                let univ_offset = is_large_eliminator(result_level, self_ctor_indices, top, addrs);
-                let elim_level = match univ_offset {
-                  1 => store(KLevelNode.Param(0)),
-                  0 => store(KLevelNode.Zero),
-                };
-                let block_member_idxs = derive_block_member_idxs(ind_idx, top);
-                let flat = build_flat_block(block_member_idxs, univ_offset, top, addrs);
-                let self_pos = find_rec_self_pos(ty, n_p, n_mot, n_min, n_i,
-                                                 self_major, flat, top);
-                let canonical_ty = build_rec_type(self_major, self_ind_ty, self_ctor_indices,
-                                                   ind_n_params, self_n_indices, ind_lvls,
-                                                   self_own_params, ind_idx, self_pos,
-                                                   top, addrs);
-                let ty_eq = k_is_def_eq(ty, canonical_ty, store(ListNode.Nil), top, addrs);
-                assert_eq!(ty_eq, 1);
-                let flat_idxs = flat_ind_idxs(flat);
-                let n_motives = list_length(flat);
-                let n_rec_params = ind_n_params;
-                let motive_base = n_rec_params;
-                let flat_own_params = flat_own_params_of(flat, top);
-                let motive_doms = build_all_motives(flat, ind_n_params,
-                                                    ind_lvls, elim_level, univ_offset,
-                                                    n_rec_params, top, addrs);
-                let minor_doms = build_all_minors(flat, flat_idxs, flat_own_params,
-                                                   n_rec_params, n_motives,
-                                                   ind_lvls, univ_offset, motive_base, top, addrs, 0);
-                let n_minors = list_length(minor_doms);
-                -- Rules cover SELF's ctors only. ctor_pos_offset = sum of
-                -- |ctors| for flat members preceding self in flat order.
-                -- Count by POSITION (self_pos), not by idx: same-idx aux
-                -- members would stop the walk at the first occurrence.
-                let ctor_pos_offset = ctors_before_pos(flat_idxs, self_pos, top, 0);
-                let occ_us = build_param_lvls_range(univ_offset, ind_lvls, 0);
-                let ind_ty_inst = expr_inst_levels(ind_ty, occ_us);
-                let params_walk = collect_n_doms(ind_ty_inst, ind_n_params);
-                match params_walk {
-                  (param_doms, _) =>
-                    let peer_recs = build_peer_recs(flat, rec_block, top);
-                    -- Self's flat member by signature-resolved position
-                    -- (idx lookup would alias same-idx aux recursors).
-                    let self_member = flat_member_at(flat, self_pos);
-                    let self_is_aux = match self_member { (_, ia, _, _) => ia, };
-                    let self_spec_params = match self_member { (_, _, sp, _) => sp, };
-                    let self_occ_us = match self_member { (_, _, _, ou) => ou, };
-                    let canonical_rules = populate_rules(rec_idx, self_major, self_ctor_indices,
-                                                         ind_n_params, n_motives, n_minors,
-                                                         ind_lvls, univ_offset,
-                                                         motive_doms, minor_doms, param_doms,
-                                                         peer_recs, flat, flat_idxs, flat_own_params,
-                                                         self_is_aux, self_spec_params, self_occ_us,
-                                                         top, addrs, ctor_pos_offset);
-                    compare_rules(rules, canonical_rules, top, addrs),
-                },
-            },
-        },
-    }
-  }
-
-  -- Build flat block members: [originals from block_member_idxs] ++
-  -- [auxes from gather_block_nested]. Each entry is (ind_idx, is_aux,
-  -- spec_params, occurrence_us). For originals: is_aux=0, spec_params=[],
-  -- occurrence_us = build_param_lvls_range(univ_offset, lvls, 0). For
-  -- auxes: is_aux=1, ind_idx=ext_ind_idx, spec_params=detected substitution
-  -- exprs, occurrence_us = univ args from the actual nested ref.
-  -- Mirror: src/ix/kernel/inductive.rs:490-601 build_flat_block.
-  -- Queue-based fixed-point build. Mirror `crates/kernel/src/inductive.rs`
-  -- `build_flat_block:531-599`. Seed with originals, then iteratively scan
-  -- every discovered member's ctors for further nested occurrences; every
-  -- newly-detected aux gets pushed onto the flat list AND its own ctors
-  -- scanned in the next round.
-  fn build_flat_block(block_member_idxs: List‹G›, univ_offset: G,
-                      top: List‹&KConstantInfo›, addrs: List‹Addr›)
-                      -> List‹(G, G, List‹KExpr›, List‹KLevel›)› {
-    let originals = build_flat_originals(block_member_idxs, univ_offset, top);
-    let flat = build_flat_block_iter(originals, 0, block_member_idxs, top, addrs);
-    -- Mirror: inductive.rs:2293-2321 — the stored recursors bake in the
-    -- COMPILER's canonical aux order (sort_consts over synthetic aux
-    -- views), while the queue above discovers auxes in traversal order.
-    -- Re-sort the aux suffix canonically so position-by-position recursor
-    -- matching sees the layout the compiler used. With ≤1 aux any order
-    -- is canonical (Rust guards flat.len() > n_originals + 1).
-    let n_originals = list_length(block_member_idxs);
-    let n_aux = list_length(flat) - n_originals;
-    match u32_less_than(1, n_aux) {
-      0 => flat,
-      1 => canonicalize_flat_auxes(flat, n_originals, top, addrs),
-    }
-  }
-
-  fn build_flat_block_iter(flat: List‹(G, G, List‹KExpr›, List‹KLevel›)›,
-                           qi: G, block_member_idxs: List‹G›,
-                           top: List‹&KConstantInfo›, addrs: List‹Addr›)
-                           -> List‹(G, G, List‹KExpr›, List‹KLevel›)› {
-    let n = list_length(flat);
-    let more = u32_less_than(qi, n);
-    match more {
-      0 => flat,
-      _ =>
-        let member = flat_member_at(flat, qi);
-        match member {
-          (m_idx, is_aux, sp, ou) =>
-            let new_triples = detect_nested_in_member(m_idx, is_aux, sp, ou,
-                                                       block_member_idxs, top, addrs);
-            let flat_updated = flat_append_new_auxes(flat, new_triples);
-            build_flat_block_iter(flat_updated, qi + 1, block_member_idxs, top, addrs),
-        },
-    }
-  }
-
-  fn detect_nested_in_member(m_idx: G, is_aux: G,
-                             spec_params: List‹KExpr›,
-                             occ_us: List‹KLevel›,
-                             block_idxs: List‹G›,
-                             top: List‹&KConstantInfo›,
-                             addrs: List‹Addr›)
-                             -> List‹(G, List‹KExpr›, List‹KLevel›)› {
-    let ci = load(list_lookup(top, m_idx));
-    match ci {
-      KConstantInfo.Induct(_, _, n_params, _, ctor_indices, _, _) =>
-        detect_nested_in_member_ctors(ctor_indices, n_params, is_aux,
-                                       spec_params, occ_us, block_idxs, top, addrs),
-      _ => store(ListNode.Nil),
-    }
-  }
-
-  fn detect_nested_in_member_ctors(ctor_indices: List‹G›, n_params: G,
-                                    is_aux: G, spec_params: List‹KExpr›,
-                                    occ_us: List‹KLevel›,
-                                    block_idxs: List‹G›,
-                                    top: List‹&KConstantInfo›,
-                                    addrs: List‹Addr›)
-                                    -> List‹(G, List‹KExpr›, List‹KLevel›)› {
-    match load(ctor_indices) {
-      ListNode.Nil => store(ListNode.Nil),
-      ListNode.Cons(ctor_idx, rest) =>
-        let ctor_ci = load(list_lookup(top, ctor_idx));
-        match ctor_ci {
-          KConstantInfo.Ctor(_, ctor_ty, _, _, _, _, _) =>
-            let body = match is_aux {
-              -- Instantiate the ctor's level params with the member's
-              -- occurrence universes BEFORE scanning (mirror inductive.rs
-              -- queue scan). For originals occ_us is the univ_offset-shifted
-              -- Param range, so occurrences found inside carry rec-frame
-              -- concrete levels — without this, aux members store raw
-              -- block-frame Params and every large-eliminator minor built
-              -- from them references the wrong universe (Param 0 where the
-              -- stored recursor has Param 1).
-              0 => peel_n_foralls_tolerant(expr_inst_levels(ctor_ty, occ_us), n_params),
-              _ => synth_aux_ctor_ty(ctor_ty, n_params, spec_params, occ_us, top, addrs),
-            };
-            let from_this = detect_nested_in_field_chain(body, block_idxs, top, 0);
-            let from_rest = detect_nested_in_member_ctors(rest, n_params, is_aux,
-                                                          spec_params, occ_us,
-                                                          block_idxs, top, addrs);
-            list_concat(from_this, from_rest),
-          _ => detect_nested_in_member_ctors(rest, n_params, is_aux,
-                                              spec_params, occ_us, block_idxs, top, addrs),
-        },
-    }
-  }
-
-  fn flat_append_new_auxes(flat: List‹(G, G, List‹KExpr›, List‹KLevel›)›,
-                           new_triples: List‹(G, List‹KExpr›, List‹KLevel›)›)
-                           -> List‹(G, G, List‹KExpr›, List‹KLevel›)› {
-    match load(new_triples) {
-      ListNode.Nil => flat,
-      ListNode.Cons(t, rest) =>
-        match t {
-          (idx, sp, ou) =>
-            match flat_contains_aux(flat, idx, sp) {
-              1 => flat_append_new_auxes(flat, rest),
-              _ =>
-                let singleton = store(ListNode.Cons((idx, 1, sp, ou),
-                                                     store(ListNode.Nil)));
-                let flat_appended = list_concat(flat, singleton);
-                flat_append_new_auxes(flat_appended, rest),
-            },
-        },
-    }
-  }
-
-  -- Dedup key = (ext ind idx, spec_params). Two auxes on the same
-  -- external inductive with different spec_params are distinct flat
-  -- members (Rust: aux_seen keyed on (addr, spec param hashes),
-  -- inductive.rs:732-743). A non-aux entry matches on idx alone —
-  -- block originals are never re-added as auxes (Rust: the !is_aux
-  -- flat skip at inductive.rs:672). spec_params are compared
-  -- element-wise by ptr_val: both sides are stored in the de-lifted
-  -- recursor-param frame, and the executor interns stores by content,
-  -- so equal content means equal ptr in honest traces; a de-interned
-  -- malicious witness can only cause a dedup MISS (extra aux → flat
-  -- count mismatch → reject), never a false collapse.
-  fn flat_contains_aux(flat: List‹(G, G, List‹KExpr›, List‹KLevel›)›,
-                       target_idx: G, target_sp: List‹KExpr›) -> G {
-    match load(flat) {
-      ListNode.Nil => 0,
-      ListNode.Cons(m, rest) =>
-        match m {
-          (idx, is_aux, sp, _ou) =>
-            match (u32_less_than(idx, target_idx) + u32_less_than(target_idx, idx)) {
-              0 =>
-                match is_aux {
-                  0 => 1,
-                  _ =>
-                    match spec_params_ptr_eq(sp, target_sp) {
-                      1 => 1,
-                      0 => flat_contains_aux(rest, target_idx, target_sp),
-                    },
-                },
-              _ => flat_contains_aux(rest, target_idx, target_sp),
-            },
-        },
-    }
-  }
-
-  fn spec_params_ptr_eq(a: List‹KExpr›, b: List‹KExpr›) -> G {
-    match load(a) {
-      ListNode.Nil =>
-        match load(b) {
-          ListNode.Nil => 1,
-          ListNode.Cons(_, _) => 0,
-        },
-      ListNode.Cons(x, xs) =>
-        match load(b) {
-          ListNode.Nil => 0,
-          ListNode.Cons(y, ys) =>
-            match ptr_val(x) - ptr_val(y) {
-              0 => spec_params_ptr_eq(xs, ys),
-              _ => 0,
-            },
-        },
-    }
-  }
-
-  fn build_flat_originals(block_member_idxs: List‹G›, univ_offset: G,
-                          top: List‹&KConstantInfo›)
-                          -> List‹(G, G, List‹KExpr›, List‹KLevel›)› {
-    match load(block_member_idxs) {
-      ListNode.Nil => store(ListNode.Nil),
-      ListNode.Cons(idx, rest) =>
-        let ci = load(list_lookup(top, idx));
-        match ci {
-          KConstantInfo.Induct(lvls, _, _, _, _, _, _) =>
-            let occ_us = build_param_lvls_range(univ_offset, lvls, 0);
-            store(ListNode.Cons((idx, 0, store(ListNode.Nil), occ_us),
-              build_flat_originals(rest, univ_offset, top))),
-          _ =>
-            store(ListNode.Cons((idx, 0, store(ListNode.Nil), store(ListNode.Nil)),
-              build_flat_originals(rest, univ_offset, top))),
-        },
-    }
-  }
-
-  -- Project per-member ind_idx from flat list.
-  fn flat_ind_idxs(flat: List‹(G, G, List‹KExpr›, List‹KLevel›)›) -> List‹G› {
-    match load(flat) {
-      ListNode.Nil => store(ListNode.Nil),
-      ListNode.Cons(m, rest) =>
-        match m {
-          (ind_idx, _, _, _) =>
-            store(ListNode.Cons(ind_idx, flat_ind_idxs(rest))),
-        },
-    }
-  }
-
-  -- Look up nth flat member.
-  fn flat_member_at(flat: List‹(G, G, List‹KExpr›, List‹KLevel›)›, n: G)
-                    -> (G, G, List‹KExpr›, List‹KLevel›) {
-    match load(flat) {
-      ListNode.Nil => (0, 0, store(ListNode.Nil), store(ListNode.Nil)),
-      ListNode.Cons(m, rest) =>
-        match n {
-          0 => m,
-          _ => flat_member_at(rest, n - 1),
-        },
-    }
-  }
-
-  -- ============================================================================
-  -- Canonical aux order. Mirror: inductive.rs:1058+ canonical_aux_order.
-  --
-  -- The compiler sorted the synthesized auxes canonically (sort_consts
-  -- over synthetic aux views) before generating recursors; the queue
-  -- discovery above yields traversal order. Reconstruct the compiler's
-  -- order by partition refinement over aux ORDINALS (0-based positions
-  -- in the discovered aux suffix), comparing synthetic views:
-  --
-  --   view(o) = ext's type/ctor types with the occurrence's universe args
-  --   instantiated, spec_params substituted, nested aux occurrences
-  --   rewritten to sentinel consts `Const(|top| + o, block_us)`, and the
-  --   block params wrapped back on.
-  --
-  -- Sentinels are the positional analogue of Rust's synthetic addresses:
-  -- fixed per ordinal (views synthesize once, memoized), and each
-  -- refinement round's ctx maps them to their CURRENT class — same-class
-  -- aux refs compare weak-Equal, exactly like block-local refs in the
-  -- canonical block sort. Compile-side dedup collapses alpha-equivalent
-  -- auxes, so refinement ends in singleton classes; a residual tie keeps
-  -- discovery order (its members are alpha-equivalent, so either order
-  -- yields def-eq recursor types).
-  -- ============================================================================
-  fn canonicalize_flat_auxes(flat: List‹(G, G, List‹KExpr›, List‹KLevel›)›,
-                             n_originals: G,
-                             top: List‹&KConstantInfo›, addrs: List‹Addr›)
-                             -> List‹(G, G, List‹KExpr›, List‹KLevel›)› {
-    let originals = list_take(flat, n_originals);
-    let aux = list_drop(flat, n_originals);
-    -- Block params + universes from the first original (mirror rs:2296:
-    -- block_us = flat[0].occurrence_us; binders from the first ind_ty).
-    let first = flat_member_at(flat, 0);
-    match first {
-      (first_idx, _, _, first_ou) =>
-        let first_ci = load(list_lookup(top, first_idx));
-        match first_ci {
-          KConstantInfo.Induct(_, f_ind_ty, f_n_params, _, _, _, _) =>
-            let pd = collect_n_doms(f_ind_ty, f_n_params);
-            match pd {
-              (block_param_doms, _) =>
-                let sbase = list_length(top);
-                let m = list_length(aux);
-                let seed = store(ListNode.Cons(ordinal_range(0, m),
-                                               store(ListNode.Nil)));
-                let classes = aux_refine_loop(seed, aux, first_ou, f_n_params,
-                                              block_param_doms, sbase,
-                                              top, addrs, m + 1);
-                let order = flatten_classes(classes);
-                list_concat(originals, permute_flat(order, aux)),
-            },
-          _ => flat,
-        },
-    }
-  }
-
-  fn ordinal_range(i: G, n: G) -> List‹G› {
-    match n - i {
-      0 => store(ListNode.Nil),
-      _ => store(ListNode.Cons(i, ordinal_range(i + 1, n))),
-    }
-  }
-
-  fn permute_flat(order: List‹G›,
-                  aux: List‹(G, G, List‹KExpr›, List‹KLevel›)›)
-                  -> List‹(G, G, List‹KExpr›, List‹KLevel›)› {
-    match load(order) {
-      ListNode.Nil => store(ListNode.Nil),
-      ListNode.Cons(o, rest) =>
-        store(ListNode.Cons(flat_member_at(aux, o), permute_flat(rest, aux))),
-    }
-  }
-
-  -- Partition refinement over aux ordinals (specialization of
-  -- CanonicalCheck's sort_kconsts to synthetic aux views).
-  fn aux_refine_loop(classes: List‹List‹G››,
-                     aux: List‹(G, G, List‹KExpr›, List‹KLevel›)›,
-                     block_us: List‹KLevel›, n_block_params: G,
-                     block_param_doms: List‹KExpr›, sbase: G,
-                     top: List‹&KConstantInfo›, addrs: List‹Addr›,
-                     fuel: G) -> List‹List‹G›› {
-    match fuel {
-      0 => classes,
-      _ =>
-        let ctx = aux_classes_ctx(classes, sbase, 0);
-        let new_classes = aux_refine_classes(classes, ctx, aux, block_us,
-                                             n_block_params, block_param_doms,
-                                             sbase, top, addrs);
-        match classes_eq(classes, new_classes) {
-          1 => classes,
-          _ => aux_refine_loop(new_classes, aux, block_us, n_block_params,
-                               block_param_doms, sbase, top, addrs, fuel - 1),
-        },
-    }
-  }
-
-  -- ctx: every ordinal's sentinel maps to its class index (all members of
-  -- one class share the index — weak-Equal under ctx_cmp_idx).
-  fn aux_classes_ctx(classes: List‹List‹G››, sbase: G, k: G) -> List‹(G, G)› {
-    match load(classes) {
-      ListNode.Nil => store(ListNode.Nil),
-      ListNode.Cons(c, rest) =>
-        list_concat(aux_class_entries(c, sbase, k),
-                    aux_classes_ctx(rest, sbase, k + 1)),
-    }
-  }
-
-  fn aux_class_entries(ordinals: List‹G›, sbase: G, k: G) -> List‹(G, G)› {
-    match load(ordinals) {
-      ListNode.Nil => store(ListNode.Nil),
-      ListNode.Cons(o, rest) =>
-        store(ListNode.Cons((sbase + o, k), aux_class_entries(rest, sbase, k))),
-    }
-  }
-
-  fn aux_refine_classes(classes: List‹List‹G››, ctx: List‹(G, G)›,
-                        aux: List‹(G, G, List‹KExpr›, List‹KLevel›)›,
-                        block_us: List‹KLevel›, n_block_params: G,
-                        block_param_doms: List‹KExpr›, sbase: G,
-                        top: List‹&KConstantInfo›, addrs: List‹Addr›)
-                        -> List‹List‹G›› {
-    match load(classes) {
-      ListNode.Nil => store(ListNode.Nil),
-      ListNode.Cons(c, rest) =>
-        let refined = aux_refine_one(c, ctx, aux, block_us, n_block_params,
-                                     block_param_doms, sbase, top, addrs);
-        list_concat(refined, aux_refine_classes(rest, ctx, aux, block_us,
-                                                n_block_params, block_param_doms,
-                                                sbase, top, addrs)),
-    }
-  }
-
-  fn aux_refine_one(c: List‹G›, ctx: List‹(G, G)›,
-                    aux: List‹(G, G, List‹KExpr›, List‹KLevel›)›,
-                    block_us: List‹KLevel›, n_block_params: G,
-                    block_param_doms: List‹KExpr›, sbase: G,
-                    top: List‹&KConstantInfo›, addrs: List‹Addr›)
-                    -> List‹List‹G›› {
-    match list_length(c) {
-      0 => store(ListNode.Nil),
-      1 => store(ListNode.Cons(c, store(ListNode.Nil))),
-      _ =>
-        let sorted = aux_insertion_sort(c, ctx, aux, block_us, n_block_params,
-                                        block_param_doms, sbase, top, addrs);
-        aux_group_consecutive(sorted, ctx, aux, block_us, n_block_params,
-                              block_param_doms, sbase, top, addrs),
-    }
-  }
-
-  fn aux_insertion_sort(xs: List‹G›, ctx: List‹(G, G)›,
-                        aux: List‹(G, G, List‹KExpr›, List‹KLevel›)›,
-                        block_us: List‹KLevel›, n_block_params: G,
-                        block_param_doms: List‹KExpr›, sbase: G,
-                        top: List‹&KConstantInfo›, addrs: List‹Addr›) -> List‹G› {
-    match load(xs) {
-      ListNode.Nil => store(ListNode.Nil),
-      ListNode.Cons(x, rest) =>
-        aux_insert_sorted(x, aux_insertion_sort(rest, ctx, aux, block_us,
-                                                n_block_params, block_param_doms,
-                                                sbase, top, addrs),
-                          ctx, aux, block_us, n_block_params, block_param_doms,
-                          sbase, top, addrs),
-    }
-  }
-
-  fn aux_insert_sorted(x: G, sorted: List‹G›, ctx: List‹(G, G)›,
-                       aux: List‹(G, G, List‹KExpr›, List‹KLevel›)›,
-                       block_us: List‹KLevel›, n_block_params: G,
-                       block_param_doms: List‹KExpr›, sbase: G,
-                       top: List‹&KConstantInfo›, addrs: List‹Addr›) -> List‹G› {
-    match load(sorted) {
-      ListNode.Nil => store(ListNode.Cons(x, store(ListNode.Nil))),
-      ListNode.Cons(h, rest) =>
-        let cmp = compare_aux_view(x, h, ctx, aux, block_us, n_block_params,
-                                   block_param_doms, sbase, top, addrs);
-        match cmp {
-          -- STABLE on ties: `x` precedes every discovery-later element it
-          -- compares Equal to (insertion processes discovery order
-          -- head-first, so `x` is earlier than everything in `sorted`).
-          -- Rust's sort_by_compare is a stable merge sort; an unstable
-          -- insert here REVERSED tied pairs — content-identical auxes with
-          -- phantom-distinct spec_params (DedupM's Bar2⟨·,Nat⟩ vs
-          -- Bar2⟨·,Bool⟩) would swap and break rec-type matching.
-          (2, _) => store(ListNode.Cons(h, aux_insert_sorted(x, rest, ctx, aux,
-                                                        block_us, n_block_params,
-                                                        block_param_doms, sbase,
-                                                        top, addrs))),
-          _ => store(ListNode.Cons(x, sorted)),
-        },
-    }
-  }
-
-  fn aux_group_consecutive(sorted: List‹G›, ctx: List‹(G, G)›,
-                           aux: List‹(G, G, List‹KExpr›, List‹KLevel›)›,
-                           block_us: List‹KLevel›, n_block_params: G,
-                           block_param_doms: List‹KExpr›, sbase: G,
-                           top: List‹&KConstantInfo›, addrs: List‹Addr›)
-                           -> List‹List‹G›› {
-    match load(sorted) {
-      ListNode.Nil => store(ListNode.Nil),
-      ListNode.Cons(h, rest) =>
-        aux_group_walk(rest, ctx, aux, block_us, n_block_params,
-                       block_param_doms, sbase, top, addrs, h,
-                       store(ListNode.Cons(h, store(ListNode.Nil)))),
-    }
-  }
-
-  fn aux_group_walk(remaining: List‹G›, ctx: List‹(G, G)›,
-                    aux: List‹(G, G, List‹KExpr›, List‹KLevel›)›,
-                    block_us: List‹KLevel›, n_block_params: G,
-                    block_param_doms: List‹KExpr›, sbase: G,
-                    top: List‹&KConstantInfo›, addrs: List‹Addr›,
-                    last: G, group: List‹G›) -> List‹List‹G›› {
-    match load(remaining) {
-      ListNode.Nil => store(ListNode.Cons(group, store(ListNode.Nil))),
-      ListNode.Cons(h, rest) =>
-        let cmp = compare_aux_view(last, h, ctx, aux, block_us, n_block_params,
-                                   block_param_doms, sbase, top, addrs);
-        match cmp {
-          (1, _) =>
-            aux_group_walk(rest, ctx, aux, block_us, n_block_params,
-                           block_param_doms, sbase, top, addrs, h,
-                           list_snoc(group, h)),
-          _ =>
-            store(ListNode.Cons(group,
-              aux_group_walk(rest, ctx, aux, block_us, n_block_params,
-                             block_param_doms, sbase, top, addrs, h,
-                             store(ListNode.Cons(h, store(ListNode.Nil)))))),
-        },
-    }
-  }
-
-  -- Compare two aux ordinals via their synthetic views. Mirror:
-  -- compare_kindc field order. unsafe / lvls / params are equal for every
-  -- synthetic aux by construction (safe, |block_us|, n_block_params), so
-  -- the chain starts at indices.
-  fn compare_aux_view(a: G, b: G, ctx: List‹(G, G)›,
-                      aux: List‹(G, G, List‹KExpr›, List‹KLevel›)›,
-                      block_us: List‹KLevel›, n_block_params: G,
-                      block_param_doms: List‹KExpr›, sbase: G,
-                      top: List‹&KConstantInfo›, addrs: List‹Addr›) -> (G, G) {
-    let ma = flat_member_at(aux, a);
-    let mb = flat_member_at(aux, b);
-    match ma {
-      (ext_a, _, sp_a, ou_a) =>
-        match mb {
-          (ext_b, _, sp_b, ou_b) =>
-            let ci_a = load(list_lookup(top, ext_a));
-            let ci_b = load(list_lookup(top, ext_b));
-            match ci_a {
-              KConstantInfo.Induct(_, ty_a, np_a, ni_a, ctors_a, _, _) =>
-                match ci_b {
-                  KConstantInfo.Induct(_, ty_b, np_b, ni_b, ctors_b, _, _) =>
-                    sord_then(sord_of_g(ord_cmp_g(ni_a, ni_b)),
-                      sord_then(sord_of_g(ord_cmp_g(list_length(ctors_a),
-                                                    list_length(ctors_b))),
-                        sord_then(compare_kexpr_ctx(
-                                    aux_view_ind_ty(ty_a, np_a, sp_a, ou_a, aux,
-                                                    block_us, n_block_params,
-                                                    block_param_doms, sbase,
-                                                    top, addrs),
-                                    aux_view_ind_ty(ty_b, np_b, sp_b, ou_b, aux,
-                                                    block_us, n_block_params,
-                                                    block_param_doms, sbase,
-                                                    top, addrs),
-                                    ctx, addrs),
-                          sord_then(aux_view_ctors_cmp(ctors_a, np_a, sp_a, ou_a,
-                                                       ctors_b, np_b, sp_b, ou_b,
-                                                       aux, block_us, n_block_params,
-                                                       block_param_doms, sbase, ctx,
-                                                       top, addrs),
-                            -- Trailing identity marker (mirror
-                            -- inductive.rs canonical_aux_order): the ext
-                            -- applied to its occurrence universes and spec
-                            -- params, NOT sentinel-rewritten. Distinct exts
-                            -- (or phantom-distinct spec params over one
-                            -- ext) whose field views tie weak through
-                            -- sentinels are ordered strongly here —
-                            -- external consts by address, block-local refs
-                            -- by ctx class. Address-equal spec params still
-                            -- compare Equal and collapse.
-                            compare_kexpr_ctx(
-                              aux_marker_view(ext_a, ou_a, sp_a),
-                              aux_marker_view(ext_b, ou_b, sp_b),
-                              ctx, addrs))))),
-                  _ => sord_eq_strong(),
-                },
-              _ => sord_eq_strong(),
-            },
-        },
-    }
-  }
-
-  -- The aux's nested-occurrence identity: `Ext spec_params` under the
-  -- occurrence's universe args. Mirror: the synthetic trailing marker
-  -- ctor in inductive.rs canonical_aux_order.
-  fn aux_marker_view(ext_idx: G, ou: List‹KLevel›, sp: List‹KExpr›) -> KExpr {
-    apply_spine(store(KExprNode.Const(ext_idx, ou)), sp)
-  }
-
-  fn aux_view_ind_ty(ext_ty: KExpr, ext_np: G, sp: List‹KExpr›,
-                     ou: List‹KLevel›,
-                     aux: List‹(G, G, List‹KExpr›, List‹KLevel›)›,
-                     block_us: List‹KLevel›, n_block_params: G,
-                     block_param_doms: List‹KExpr›, sbase: G,
-                     top: List‹&KConstantInfo›, addrs: List‹Addr›) -> KExpr {
-    let inst = expr_inst_levels(ext_ty, ou);
-    let body = synth_aux_subst(inst, ext_np, sp, 0, top, addrs);
-    let body_r = aux_sentinel_replace(body, aux, block_us, n_block_params,
-                                      sbase, 0);
-    wrap_foralls(body_r, block_param_doms)
-  }
-
-  -- Zip ext ctors of both views. compare_kctor field order: lvls / cidx /
-  -- params are equal by construction (|block_us|, position i,
-  -- n_block_params); fields then ty decide.
-  fn aux_view_ctors_cmp(ctors_a: List‹G›, np_a: G, sp_a: List‹KExpr›,
-                        ou_a: List‹KLevel›,
-                        ctors_b: List‹G›, np_b: G, sp_b: List‹KExpr›,
-                        ou_b: List‹KLevel›,
-                        aux: List‹(G, G, List‹KExpr›, List‹KLevel›)›,
-                        block_us: List‹KLevel›, n_block_params: G,
-                        block_param_doms: List‹KExpr›, sbase: G,
-                        ctx: List‹(G, G)›,
-                        top: List‹&KConstantInfo›, addrs: List‹Addr›) -> (G, G) {
-    match load(ctors_a) {
-      ListNode.Nil => sord_eq_strong(),
-      ListNode.Cons(ca, rest_a) =>
-        match load(ctors_b) {
-          ListNode.Nil => sord_eq_strong(),
-          ListNode.Cons(cb, rest_b) =>
-            let ci_a = load(list_lookup(top, ca));
-            let ci_b = load(list_lookup(top, cb));
-            match ci_a {
-              KConstantInfo.Ctor(_, cty_a, _, _, _, nf_a, _) =>
-                match ci_b {
-                  KConstantInfo.Ctor(_, cty_b, _, _, _, nf_b, _) =>
-                    sord_then(sord_of_g(ord_cmp_g(nf_a, nf_b)),
-                      sord_then(compare_kexpr_ctx(
-                                  aux_view_ctor_ty(cty_a, np_a, sp_a, ou_a, aux,
-                                                   block_us, n_block_params,
-                                                   block_param_doms, sbase,
-                                                   top, addrs),
-                                  aux_view_ctor_ty(cty_b, np_b, sp_b, ou_b, aux,
-                                                   block_us, n_block_params,
-                                                   block_param_doms, sbase,
-                                                   top, addrs),
-                                  ctx, addrs),
-                        aux_view_ctors_cmp(rest_a, np_a, sp_a, ou_a,
-                                           rest_b, np_b, sp_b, ou_b,
-                                           aux, block_us, n_block_params,
-                                           block_param_doms, sbase, ctx,
-                                           top, addrs))),
-                  _ => sord_eq_strong(),
-                },
-              _ => sord_eq_strong(),
-            },
-        },
-    }
-  }
-
-  fn aux_view_ctor_ty(ext_cty: KExpr, ext_np: G, sp: List‹KExpr›,
-                      ou: List‹KLevel›,
-                      aux: List‹(G, G, List‹KExpr›, List‹KLevel›)›,
-                      block_us: List‹KLevel›, n_block_params: G,
-                      block_param_doms: List‹KExpr›, sbase: G,
-                      top: List‹&KConstantInfo›, addrs: List‹Addr›) -> KExpr {
-    let body = synth_aux_ctor_ty(ext_cty, ext_np, sp, ou, top, addrs);
-    let body_r = aux_sentinel_replace(body, aux, block_us, n_block_params,
-                                      sbase, 0);
-    wrap_foralls(body_r, block_param_doms)
-  }
-
-  -- ============================================================================
-  -- Sentinel rewriting. Mirror: inductive.rs:776-957
-  -- replace_aux_refs_for_sort / try_replace_aux_ref_for_sort, with
-  -- sentinel positions standing in for synthetic addresses. Occurrences
-  -- of `ext spec_params… idx_args…` become
-  -- `Const(sbase + ordinal, block_us) block_param_vars… idx_args…`
-  -- (pre-wrap frame: block param pi at BVar(d + n_block_params - 1 - pi)).
-  -- Spec args match syntactically after lifting by the local binder
-  -- depth — detection extracted them syntactically from the same frame.
-  -- ============================================================================
-  fn aux_sentinel_replace(e: KExpr,
-                          aux: List‹(G, G, List‹KExpr›, List‹KLevel›)›,
-                          block_us: List‹KLevel›, n_block_params: G,
-                          sbase: G, d: G) -> KExpr {
-    let attempt = aux_sentinel_try(e, aux, block_us, n_block_params, sbase, d);
-    match attempt {
-      (1, replaced) => replaced,
-      (_, _) =>
-        match load(e) {
-          KExprNode.App(f, a) =>
-            store(KExprNode.App(
-              aux_sentinel_replace(f, aux, block_us, n_block_params, sbase, d),
-              aux_sentinel_replace(a, aux, block_us, n_block_params, sbase, d))),
-          KExprNode.Lam(t, b) =>
-            store(KExprNode.Lam(
-              aux_sentinel_replace(t, aux, block_us, n_block_params, sbase, d),
-              aux_sentinel_replace(b, aux, block_us, n_block_params, sbase, d + 1))),
-          KExprNode.Forall(t, b) =>
-            store(KExprNode.Forall(
-              aux_sentinel_replace(t, aux, block_us, n_block_params, sbase, d),
-              aux_sentinel_replace(b, aux, block_us, n_block_params, sbase, d + 1))),
-          KExprNode.Let(t, v, b) =>
-            store(KExprNode.Let(
-              aux_sentinel_replace(t, aux, block_us, n_block_params, sbase, d),
-              aux_sentinel_replace(v, aux, block_us, n_block_params, sbase, d),
-              aux_sentinel_replace(b, aux, block_us, n_block_params, sbase, d + 1))),
-          KExprNode.Proj(t, f, e1) =>
-            store(KExprNode.Proj(t, f,
-              aux_sentinel_replace(e1, aux, block_us, n_block_params, sbase, d))),
-          _ => e,
-        },
-    }
-  }
-
-  fn aux_sentinel_try(e: KExpr,
-                      aux: List‹(G, G, List‹KExpr›, List‹KLevel›)›,
-                      block_us: List‹KLevel›, n_block_params: G,
-                      sbase: G, d: G) -> (G, KExpr) {
-    let spine = collect_spine(e);
-    match spine {
-      (head, args) =>
-        match load(head) {
-          KExprNode.Const(hidx, _) =>
-            aux_sentinel_scan(e, hidx, args, aux, block_us, n_block_params,
-                              sbase, d, 0),
-          _ => (0, e),
-        },
-    }
-  }
-
-  fn aux_sentinel_scan(orig: KExpr, hidx: G, args: List‹KExpr›,
-                       aux: List‹(G, G, List‹KExpr›, List‹KLevel›)›,
-                       block_us: List‹KLevel›, n_block_params: G,
-                       sbase: G, d: G, o: G) -> (G, KExpr) {
-    match load(aux) {
-      ListNode.Nil => (0, orig),
-      ListNode.Cons(m, rest) =>
-        match m {
-          (ext_idx, _, sp, _ou) =>
-            match ext_idx - hidx {
-              0 =>
-                let own = list_length(sp);
-                match u32_less_than(list_length(args), own) {
-                  1 => aux_sentinel_scan(orig, hidx, args, rest, block_us,
-                                         n_block_params, sbase, d, o + 1),
-                  0 =>
-                    match aux_spec_args_match(args, sp, d) {
-                      0 => aux_sentinel_scan(orig, hidx, args, rest, block_us,
-                                             n_block_params, sbase, d, o + 1),
-                      1 =>
-                        let head2 = store(KExprNode.Const(sbase + o, block_us));
-                        let with_params = aux_apply_block_vars(head2,
-                                                               n_block_params,
-                                                               d, 0);
-                        (1, apply_spine(with_params, list_drop(args, own))),
-                    },
-                },
-              _ => aux_sentinel_scan(orig, hidx, args, rest, block_us,
-                                     n_block_params, sbase, d, o + 1),
-            },
-        },
-    }
-  }
-
-  fn aux_spec_args_match(args: List‹KExpr›, sps: List‹KExpr›, d: G) -> G {
-    match load(sps) {
-      ListNode.Nil => 1,
-      ListNode.Cons(sp, sp_rest) =>
-        match load(args) {
-          ListNode.Nil => 0,
-          ListNode.Cons(arg, arg_rest) =>
-            let sp_lifted = expr_lift(sp, d, 0);
-            match compare_kexpr(arg, sp_lifted) {
-              1 => aux_spec_args_match(arg_rest, sp_rest, d),
-              _ => 0,
-            },
-        },
-    }
-  }
-
-  fn aux_apply_block_vars(head: KExpr, n: G, d: G, pi: G) -> KExpr {
-    match n - pi {
-      0 => head,
-      _ =>
-        let v = store(KExprNode.BVar((d + n) - (1 + pi)));
-        aux_apply_block_vars(store(KExprNode.App(head, v)), n, d, pi + 1),
-    }
-  }
-
-  -- Build major args. Non-aux: apply n_rec_params recursor-param BVars at
-  -- decreasing positions starting from `start`. Aux: apply each spec_param
-  -- lifted by `spec_lift` — the binders between the recursor-param frame
-  -- and the major position (n_motives + n_minors + n_indices in the
-  -- recursor type).
-  fn build_major_args_for_self(head: KExpr, n_rec_params: G, start: G,
-                                spec_lift: G,
-                                is_aux: G, spec_params: List‹KExpr›) -> KExpr {
-    match is_aux {
-      0 => build_apply_bvars_decreasing(head, n_rec_params, start, 0),
-      _ => apply_spec_params_lifted(head, spec_params, spec_lift),
-    }
-  }
-
-  -- For each flat member, look up its own_params from top.
-  fn flat_own_params_of(flat: List‹(G, G, List‹KExpr›, List‹KLevel›)›,
-                       top: List‹&KConstantInfo›) -> List‹G› {
-    match load(flat) {
-      ListNode.Nil => store(ListNode.Nil),
-      ListNode.Cons(m, rest) =>
-        match m {
-          (ind_idx, _, _, _) =>
-            let ci = load(list_lookup(top, ind_idx));
-            match ci {
-              KConstantInfo.Induct(_, _, np, _, _, _, _) =>
-                store(ListNode.Cons(np, flat_own_params_of(rest, top))),
-              _ =>
-                store(ListNode.Cons(0, flat_own_params_of(rest, top))),
-            },
-        },
-    }
-  }
-
-  -- Find the primary inductive for the canonical block of a recursor.
-  -- Walk recs in `rec_block`; pick the first one whose major's `nested > 0`
-  -- (= the original Indc whose ctors carry nested occurrences). Returns
-  -- (found, ind_idx); on `found = 0` callers fall back to `self_major`.
-  fn resolve_primary_ind_for_rec(self_major: G, rec_block: Addr,
-                                  top: List‹&KConstantInfo›) -> G {
-    match address_eq(rec_block, store([0u8; 32])) {
-      1 => self_major,
-      0 =>
-        let p = scan_primary_in_rec_block(rec_block, top, top, 0);
-        match p {
-          (1, idx) => idx,
-          _ => self_major,
-        },
-    }
-  }
-
-  -- Returns 1 iff `idx`'s own ctor fields contain a nested occurrence
-  -- (external inductive applied to args mentioning block members).
-  -- Structural replacement for the dropped Ixon `nested` count: an
-  -- original of a nested-emitting block detects non-empty; an aux (whose
-  -- specialized ctors reference only block members) and a pure-mutual
-  -- peer detect empty. Aiur memoization caches per (idx, block, top).
-  fn member_has_nested(idx: G, block_idxs: List‹G›,
-                       top: List‹&KConstantInfo›) -> G {
-    let nested = detect_nested_in_orig(idx, block_idxs, top);
-    match load(nested) {
-      ListNode.Nil => 0,
-      _ => 1,
-    }
-  }
-
-  fn any_member_has_nested(walk_idxs: List‹G›, block_idxs: List‹G›,
-                           top: List‹&KConstantInfo›) -> G {
-    match load(walk_idxs) {
-      ListNode.Nil => 0,
-      ListNode.Cons(idx, rest) =>
-        match member_has_nested(idx, block_idxs, top) {
-          1 => 1,
-          0 => any_member_has_nested(rest, block_idxs, top),
-        },
-    }
-  }
-
-  -- Returns 1 iff `ind_idx`'s block emits nested auxes.
-  fn ind_has_nested(ind_idx: G, top: List‹&KConstantInfo›) -> G {
-    let block_idxs = derive_block_member_idxs(ind_idx, top);
-    any_member_has_nested(block_idxs, block_idxs, top)
-  }
-
-  fn scan_primary_in_rec_block(rec_block: Addr,
-                               consts: List‹&KConstantInfo›,
-                               top: List‹&KConstantInfo›, idx: G) -> (G, G) {
-    match load(consts) {
-      ListNode.Nil => (0, 0),
-      ListNode.Cons(&ci, rest) =>
-        match ci {
-          KConstantInfo.Rec(_, ty, n_p, n_i, n_m, n_min, rules, _, _, ba) =>
-            match address_eq(ba, rec_block) {
-              0 => scan_primary_in_rec_block(rec_block, rest, top, idx + 1),
-              1 =>
-                let r_ind = rec_to_ind_idx_with_ty(rules, ty, n_p, n_m, n_min, n_i, top);
-                let r_ci = load(list_lookup(top, r_ind));
-                match r_ci {
-                  KConstantInfo.Induct(_, _, _, _, _, _, _) =>
-                    match ind_has_nested(r_ind, top) {
-                      0 => scan_primary_in_rec_block(rec_block, rest, top, idx + 1),
-                      _ => (1, r_ind),
-                    },
-                  _ => scan_primary_in_rec_block(rec_block, rest, top, idx + 1),
-                },
-            },
-          _ => scan_primary_in_rec_block(rec_block, rest, top, idx + 1),
-        },
-    }
-  }
-
-  -- Sum of |ctors| over the first `target_pos` block members.
-  fn ctors_before_pos(block_member_idxs: List‹G›, target_pos: G,
-                      top: List‹&KConstantInfo›, acc: G) -> G {
-    match target_pos {
-      0 => acc,
-      _ =>
-        match load(block_member_idxs) {
-          ListNode.Nil => acc,
-          ListNode.Cons(member_idx, rest) =>
-            let ci = load(list_lookup(top, member_idx));
-            match ci {
-              KConstantInfo.Induct(_, _, _, _, m_ctors, _, _) =>
-                ctors_before_pos(rest, target_pos - 1, top,
-                                 acc + list_length(m_ctors)),
-              _ => ctors_before_pos(rest, target_pos - 1, top, acc),
-            },
-        },
-    }
-  }
-
-  -- Mirror: src/ix/kernel/inductive.rs:619+
-  -- fn try_detect_nested. For each ctor of `orig_idx`, walk its fields;
-  -- for each field's domain, peel leading Foralls + check spine head:
-  -- if head is non-block Inductive AND first ext_n_params args mention
-  -- block_idxs, record (ext_idx, spec_params).
-  fn detect_nested_in_orig(orig_idx: G, block_idxs: List‹G›,
-                           top: List‹&KConstantInfo›)
-                           -> List‹(G, List‹KExpr›, List‹KLevel›)› {
-    let orig_ci = load(list_lookup(top, orig_idx));
-    match orig_ci {
-      KConstantInfo.Induct(_, _, n_params, _, ctor_indices, _, _) =>
-        detect_nested_in_ctors(ctor_indices, n_params, block_idxs, top),
-      _ => store(ListNode.Nil),
-    }
-  }
-
-  fn detect_nested_in_ctors(ctor_indices: List‹G›, n_params: G,
-                            block_idxs: List‹G›,
-                            top: List‹&KConstantInfo›)
-                            -> List‹(G, List‹KExpr›, List‹KLevel›)› {
-    match load(ctor_indices) {
-      ListNode.Nil => store(ListNode.Nil),
-      ListNode.Cons(ctor_idx, rest) =>
-        let ctor_ci = load(list_lookup(top, ctor_idx));
-        match ctor_ci {
-          KConstantInfo.Ctor(_, ctor_ty, _, _, _, _, _) =>
-            let body = peel_n_foralls_tolerant(ctor_ty, n_params);
-            let from_this = detect_nested_in_field_chain(body, block_idxs, top, 0);
-            let from_rest = detect_nested_in_ctors(rest, n_params, block_idxs, top);
-            list_concat(from_this, from_rest),
-          _ => detect_nested_in_ctors(rest, n_params, block_idxs, top),
-        },
-    }
-  }
-
-  -- `depth` = number of binders between the constructor's param context
-  -- and the current position (field binders walked so far, plus leading
-  -- foralls peeled off the domain in `detect_nested_in_dom`). Both call
-  -- paths (originals after `peel_n_foralls_tolerant`, auxes after
-  -- `synth_aux_ctor_ty` substitution) start at 0.
-  fn detect_nested_in_field_chain(ty: KExpr, block_idxs: List‹G›,
-                                   top: List‹&KConstantInfo›, depth: G)
-                                   -> List‹(G, List‹KExpr›, List‹KLevel›)› {
-    match load(ty) {
-      KExprNode.Forall(dom, body) =>
-        let from_dom = detect_nested_in_dom(dom, block_idxs, top, depth);
-        let from_rest = detect_nested_in_field_chain(body, block_idxs, top,
-                                                     depth + 1);
-        list_concat(from_dom, from_rest),
-      _ => store(ListNode.Nil),
-    }
-  }
-
-  fn detect_nested_in_dom(dom: KExpr, block_idxs: List‹G›,
-                          top: List‹&KConstantInfo›, depth: G)
-                          -> List‹(G, List‹KExpr›, List‹KLevel›)› {
-    match peel_leading_foralls(dom) {
-      (doms, body) =>
-        match collect_spine(body) {
-          (head, args) =>
-            match load(head) {
-              KExprNode.Const(idx, occ_us) =>
-                match list_contains_g(block_idxs, idx) {
-                  1 => store(ListNode.Nil),
-                  0 =>
-                    let ci = load(list_lookup(top, idx));
-                    match ci {
-                      KConstantInfo.Induct(_, _, ext_n_params, _, _, _, _) =>
-                        let n_args = list_length(args);
-                        match u32_less_than(n_args, ext_n_params) {
-                          1 => store(ListNode.Nil),
-                          0 =>
-                            let param_args = list_take(args, ext_n_params);
-                            match list_any_mentions(param_args, block_idxs) {
-                              0 => store(ListNode.Nil),
-                              1 =>
-                                -- Reject occurrences whose param args
-                                -- reference a field/domain-local binder — a
-                                -- loose BVar below the extraction depth. Not
-                                -- a valid nested-inductive parameterization;
-                                -- no aux may be synthesized. Mirror:
-                                -- crates/kernel/src/inductive.rs:723-730
-                                -- (`sp.has_fvars()` — Rust opens those
-                                -- binders as fvars, Aiur keeps de Bruijn).
-                                let d = depth + list_length(doms);
-                                match spec_params_valid(param_args, d) {
-                                  0 => store(ListNode.Nil),
-                                  1 =>
-                                    -- De-lift to the recursor-param frame
-                                    -- (block param j at BVar(n_params-1-j)):
-                                    -- the storage convention every flat
-                                    -- consumer assumes, and the frame that
-                                    -- makes the same occurrence at two
-                                    -- field depths compare equal for aux
-                                    -- dedup. Sound: the validity check
-                                    -- above guarantees no loose BVar
-                                    -- below `d`.
-                                    let lowered = spec_params_lower(param_args, d);
-                                    store(ListNode.Cons((idx, lowered, occ_us),
-                                                         store(ListNode.Nil))),
-                                },
-                            },
-                        },
-                      _ => store(ListNode.Nil),
-                    },
-                },
-              _ => store(ListNode.Nil),
-            },
-        },
-    }
-  }
-
-  -- 1 iff no spec_param references a binder below extraction depth `d`.
-  fn spec_params_valid(sps: List‹KExpr›, d: G) -> G {
-    match load(sps) {
-      ListNode.Nil => 1,
-      ListNode.Cons(sp, rest) =>
-        match has_bvar_in_range(sp, 0, d) {
-          1 => 0,
-          0 => spec_params_valid(rest, d),
-        },
-    }
-  }
-
-  fn spec_params_lower(sps: List‹KExpr›, d: G) -> List‹KExpr› {
-    match load(sps) {
-      ListNode.Nil => store(ListNode.Nil),
-      ListNode.Cons(sp, rest) =>
-        store(ListNode.Cons(expr_lower(sp, d, 0), spec_params_lower(rest, d))),
-    }
-  }
-
-  -- Walk first n Pi binders (whnf before each peel — mirror rs:1178/1221;
-  -- param binders can hide under definitional wrappers). For each,
-  -- substitute the binder's BVar(0) with spec_params[k].
-  fn synth_aux_subst(ty: KExpr, n: G, spec_params: List‹KExpr›, k: G,
-                     top: List‹&KConstantInfo›, addrs: List‹Addr›) -> KExpr {
-    match n {
-      0 => ty,
-      _ =>
-        let w = whnf(ty, store(ListNode.Nil), top, addrs);
-        match load(w) {
-          KExprNode.Forall(_, body) =>
-            let sp = list_lookup(spec_params, k);
-            let body_substed = expr_inst1(body, sp, 0);
-            synth_aux_subst(body_substed, n - 1, spec_params, k + 1, top, addrs),
-        },
-    }
-  }
-
-  -- Synthesize canonical aux.ctor_ty from ext.ctor_ty + spec_params.
-  -- Same universe instantiation + substitution, applied to a ctor type
-  -- (which has ext's params as leading Pi binders too). Mirror rs:1218-1234.
-  fn synth_aux_ctor_ty(ext_ctor_ty: KExpr, ext_n_params: G,
-                       spec_params: List‹KExpr›, occ_us: List‹KLevel›,
-                       top: List‹&KConstantInfo›, addrs: List‹Addr›) -> KExpr {
-    let inst = expr_inst_levels(ext_ctor_ty, occ_us);
-    synth_aux_subst(inst, ext_n_params, spec_params, 0, top, addrs)
-  }
-
-  fn populate_rules(rec_idx: G, ind_idx: G, ctor_indices: List‹G›,
-                    n_params: G, n_motives: G, n_minors: G,
-                    ind_lvls: G, univ_offset: G,
-                    motive_doms: List‹KExpr›, minor_doms: List‹KExpr›,
-                    param_doms: List‹KExpr›, peer_recs: List‹G›,
-                    flat: List‹(G, G, List‹KExpr›, List‹KLevel›)›,
-                    flat_idxs: List‹G›, flat_own_params: List‹G›,
-                    is_aux: G, spec_params: List‹KExpr›,
-                    occurrence_us: List‹KLevel›,
-                    top: List‹&KConstantInfo›, addrs: List‹Addr›,
-                    ctor_pos: G) -> List‹KRecRule› {
-    match load(ctor_indices) {
-      ListNode.Nil => store(ListNode.Nil),
-      ListNode.Cons(ctor_idx, rest) =>
-        let ctor_ci = load(list_lookup(top, ctor_idx));
-        match ctor_ci {
-          KConstantInfo.Ctor(_, ctor_ty, owning_ind, _, _, n_fields, _) =>
-            let rhs = build_rule_rhs(rec_idx, owning_ind, ctor_idx, ctor_ty, ctor_pos,
-                                     n_params, n_motives, n_minors, ind_lvls, univ_offset,
-                                     motive_doms, minor_doms, param_doms, peer_recs,
-                                     flat, flat_idxs, flat_own_params,
-                                     is_aux, spec_params, occurrence_us, top, addrs);
-            let rule = KRecRule.Mk(ctor_idx, n_fields, rhs);
-            store(ListNode.Cons(rule,
-              populate_rules(rec_idx, ind_idx, rest, n_params, n_motives, n_minors,
-                             ind_lvls, univ_offset, motive_doms, minor_doms, param_doms,
-                             peer_recs, flat, flat_idxs, flat_own_params,
-                             is_aux, spec_params, occurrence_us,
-                             top, addrs, ctor_pos + 1))),
-        },
-    }
-  }
-
-  -- Mirror: src/ix/kernel/inductive.rs:2817-2924 fn build_direct_ih.
-  -- Forall-wrapped recursive fields wrap IH body in matching Foralls.
-  -- For each rec field, motive at offset motive_base + member_local_idx so
-  -- multi-member blocks correctly select per-member motives.
-  -- Mirror src/ix/kernel/inductive.rs:2817-2924 fn build_direct_ih.
-  -- Each rec-field's dom may be written via reducible defs (e.g.
-  -- `constType (n α) (n α)`); we WHNF before peeling Foralls and before
-  -- collecting the inner spine so the head/args reflect the *true*
-  -- inductive occurrence rather than the surface alias.
-  fn build_ih_doms(rec_indices: List‹G›, rec_member_idxs: List‹G›,
-                   field_doms: List‹KExpr›,
-                   flat_own_params: List‹G›,
-                   motive_base: G, n_fields: G,
-                   minor_saved: G, types: List‹KExpr›,
-                   top: List‹&KConstantInfo›, addrs: List‹Addr›,
-                   k: G) -> List‹KExpr› {
-    match load(rec_indices) {
-      ListNode.Nil => store(ListNode.Nil),
-      ListNode.Cons(field_idx, rest) =>
-        let mem_idx = list_lookup(rec_member_idxs, k);
-        let target_n_params = list_lookup(flat_own_params, mem_idx);
-        let depth = minor_saved + n_fields + k;
-        let dom = list_lookup(field_doms, field_idx);
-        let dom_lifted = expr_lift(dom, (n_fields - field_idx) + k, 0);
-        let dom_w = whnf(dom_lifted, types, top, addrs);
-        match peel_leading_foralls(dom_w) {
-          (forall_doms, inner_body_raw) =>
-            let inner_types = list_concat(list_reverse(forall_doms), types);
-            let inner_body = whnf(inner_body_raw, inner_types, top, addrs);
-            let n_xs = list_length(forall_doms);
-            let inner_depth = depth + n_xs;
-            let motive_bvar = (inner_depth - 1) - (motive_base + mem_idx);
-            let field_bvar = (inner_depth - 1) - (minor_saved + field_idx);
-            match collect_spine(inner_body) {
-              (_h, dom_args) =>
-                let idx_args = list_drop(dom_args, target_n_params);
-                let motive_ref = store(KExprNode.BVar(motive_bvar));
-                let with_indices = apply_spine(motive_ref, idx_args);
-                let field_ref = store(KExprNode.BVar(field_bvar));
-                let field_app = build_apply_xs(field_ref, n_xs, 0);
-                let ih_body = store(KExprNode.App(with_indices, field_app));
-                let ih_dom = wrap_foralls(ih_body, forall_doms);
-                store(ListNode.Cons(ih_dom,
-                  build_ih_doms(rest, rec_member_idxs, field_doms, flat_own_params,
-                                motive_base, n_fields, minor_saved, types, top, addrs, k + 1))),
-            },
-        },
-    }
-  }
-
-  -- Mirror: src/ix/kernel/inductive.rs:216-250 mutual peer-loop +
-  -- 1660-1700 fn check_param_agreement.
-  -- Solo (block_addr = [0;32]) is no-op.
-  fn check_block_peer_param_agreement(self_pos: G, self_ty: KExpr,
-                                      self_n_params: G, self_n_indices: G,
-                                      block_addr: Addr,
-                                      top: List‹&KConstantInfo›,
-                                      addrs: List‹Addr›) {
-    match address_eq(block_addr, store([0u8; 32])) {
-      1 => (),
-      0 => peer_param_loop(self_pos, self_ty, self_n_params, self_n_indices,
-                           block_addr, top, top, addrs, 0),
-    }
-  }
-
-  fn peer_param_loop(self_pos: G, self_ty: KExpr,
-                     self_n_params: G, self_n_indices: G,
-                     block_addr: Addr,
-                     consts: List‹&KConstantInfo›,
-                     top: List‹&KConstantInfo›,
-                     addrs: List‹Addr›, idx: G) {
-    match load(consts) {
-      ListNode.Nil => (),
-      ListNode.Cons(&ci, rest) =>
-        match ci {
-          KConstantInfo.Induct(_, peer_ty, peer_n_params, peer_n_indices, _, _, peer_block_addr) =>
-            let same_block = address_eq(peer_block_addr, block_addr);
-            let is_self = eq_zero(idx - self_pos);
-            let should_check = same_block * (1 - is_self);
-            match should_check {
-              1 =>
-                -- S3b: param-count + param-domain agreement.
-                assert_eq!(peer_n_params, self_n_params);
-                check_param_agreement(self_ty, peer_ty, self_n_params, top, addrs);
-                -- S3: result-universe agreement. Mirror src/ix/kernel/inductive.rs:228-237.
-                let self_lvl = get_result_sort_level(self_ty, self_n_params + self_n_indices,
-                                                     store(ListNode.Nil), top, addrs);
-                let peer_lvl = get_result_sort_level(peer_ty, peer_n_params + peer_n_indices,
-                                                     store(ListNode.Nil), top, addrs);
-                assert_eq!(level_equal(self_lvl, peer_lvl), 1);
-                peer_param_loop(self_pos, self_ty, self_n_params, self_n_indices,
-                                block_addr, rest, top, addrs, idx + 1),
-              0 =>
-                peer_param_loop(self_pos, self_ty, self_n_params, self_n_indices,
-                                block_addr, rest, top, addrs, idx + 1),
-            },
-          _ =>
-            peer_param_loop(self_pos, self_ty, self_n_params, self_n_indices,
-                            block_addr, rest, top, addrs, idx + 1),
-        },
-    }
-  }
-
-  -- Walk first n Foralls of both types asserting domain def-eq under the
-  -- accumulated param-binder context.
-  fn check_param_agreement(ta: KExpr, tb: KExpr, n: G,
-                           top: List‹&KConstantInfo›, addrs: List‹Addr›) {
-    check_param_agreement_go(ta, tb, n, store(ListNode.Nil), top, addrs)
-  }
-
-  fn check_param_agreement_go(ta: KExpr, tb: KExpr, n: G,
-                              types: List‹KExpr›,
-                              top: List‹&KConstantInfo›, addrs: List‹Addr›) {
-    match n {
-      0 => (),
-      _ =>
-        match load(ta) {
-          KExprNode.Forall(da, ba) =>
-            match load(tb) {
-              KExprNode.Forall(db, bb) =>
-                let eq = k_is_def_eq(da, db, types, top, addrs);
-                assert_eq!(eq, 1);
-                let inner = store(ListNode.Cons(da, types));
-                check_param_agreement_go(ba, bb, n - 1, inner, top, addrs),
-            },
-        },
-    }
-  }
-⟧
-
-end IxVM
-
-end
diff --git a/Ix/IxVM/Kernel/Infer.lean b/Ix/IxVM/Kernel/Infer.lean
index e1798d05f..5d382aab3 100644
--- a/Ix/IxVM/Kernel/Infer.lean
+++ b/Ix/IxVM/Kernel/Infer.lean
@@ -2,170 +2,118 @@ 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
 
 namespace IxVM
 
-/-! ## Type inference over `KExpr`
+/-! ## Infer — type synthesis with checking
 
-Mirrors `src/ix/kernel/infer.rs::infer`.
-
-Local context is a `List‹KExpr›` of binder types in innermost-first order.
-A `BVar(i)` looks up `types[i]` and lifts it by `i + 1` (since the binder
-was bound `i + 1` levels up).
-
-For `Lam(ty, body)`, the inferred type is `Forall(ty, body_type)` where
-`body_type` is computed under `types ++ [ty]` (which means `Cons(ty, types)`).
-No fvars — we work directly with de Bruijn indices.
+Handles every KExpr node: Sort, BVar, Const, App, Lam, Forall, Let, Lit,
+and Proj. Unlike `InferOnly`, this performs the inner validations as it
+goes — argument types are checked against domains, binder types are
+ensured to be sorts, and projections are checked against their structure.
 -/
 
 def infer := ⟦
-  -- ============================================================================
   -- Context lookup with lift
-  --
   -- types[i] is the type of the i-th binder from the innermost. When we
   -- look up BVar(i), we get types[i] but it was assembled at depth d-i-1
   -- (counting from outermost). The current context is at depth d, so we
   -- need to lift the result by (i + 1).
-  -- ============================================================================
   fn types_lookup(types: List‹KExpr›, i: G) -> KExpr {
-    match load(types) {
-      ListNode.Nil => store(KExprNode.BVar(0)),
-      ListNode.Cons(ty, rest) =>
-        match i {
-          0 => expr_lift(ty, 1, 0),
-          _ =>
-            let inner = types_lookup(rest, i - 1);
-            expr_lift(inner, 1, 0),
-        },
+    let ty = list_lookup(types, i);
+    expr_lift(ty, i + 1, 0)
+  }
+
+  -- Mirror each KConstantInfo carries num_lvls as its first G field.
+  fn const_num_lvls(ci: KConstantInfo) -> G {
+    match ci {
+      KConstantInfo.Axiom(n, _, _) => n,
+      KConstantInfo.Defn(n, _, _, _, _) => n,
+      KConstantInfo.Thm(n, _, _) => n,
+      KConstantInfo.Opaque(n, _, _, _) => n,
+      KConstantInfo.Quot(n, _, _) => n,
+      KConstantInfo.Induct(n, _, _, _, _, _, _, _) => n,
+      KConstantInfo.Ctor(n, _, _, _, _, _, _, _) => n,
+      KConstantInfo.Rec(n, _, _, _, _, _, _, _, _, _, _) => n,
+    }
+  }
+
+  -- Helpers: extract const declared type, Nat/Str literal types.
+  fn const_type_of(ci: KConstantInfo) -> KExpr {
+    match ci {
+      KConstantInfo.Axiom(_, ty, _) => ty,
+      KConstantInfo.Defn(_, ty, _, _, _) => ty,
+      KConstantInfo.Thm(_, ty, _) => ty,
+      KConstantInfo.Opaque(_, ty, _, _) => ty,
+      KConstantInfo.Quot(_, ty, _) => ty,
+      KConstantInfo.Induct(_, ty, _, _, _, _, _, _) => ty,
+      KConstantInfo.Ctor(_, ty, _, _, _, _, _, _) => ty,
+      KConstantInfo.Rec(_, ty, _, _, _, _, _, _, _, _, _) => ty,
     }
   }
 
-  -- ============================================================================
   -- k_infer
-  --
-  -- Mirror of `src/ix/kernel/infer.rs::infer`. Per-variant dispatch.
-  --
+  -- Mirror of `crates/kernel/src/infer.rs::infer`. Per-variant dispatch.
   -- Lvls placed at outermost; level-params instantiation handled where
   -- the constant's declared type is fetched.
-  -- ============================================================================
   -- Context-trimmed memo wrapper (mirror Rust `infer_key`): key inference on
   -- the suffix of `types` reachable from `e`'s loose-bvar range, so a closed
   -- subterm (`lbr == 0`) shares its inferred type across every binder depth.
-  fn k_infer(e: KExpr, types: List‹KExpr›,
-             top: List‹&KConstantInfo›, addrs: List‹Addr›) -> KExpr {
-    k_infer_core(e, ctx_trim(types, expr_lbr(e)), top, addrs)
+  fn k_infer(e: KExpr, types: List‹KExpr›) -> KExpr {
+    k_infer_core(e, ctx_trim(types, expr_lbr(e)))
   }
 
-  fn k_infer_core(e: KExpr, types: List‹KExpr›,
-                  top: List‹&KConstantInfo›, addrs: List‹Addr›) -> KExpr {
+  fn k_infer_core(e: KExpr, types: List‹KExpr›) -> KExpr {
     match load(e) {
       KExprNode.BVar(i) => types_lookup(types, i),
 
-      -- Normalize the constructed `Succ(l)` so callers see canonical
-      -- forms (e.g. `Succ(IMax 0 1)` → `Succ(Succ Zero) = 2`). Without
-      -- this, `level_leq` for cases like `levelComp2` (`Sort(IMax 0 1)`)
-      -- has to compare `Succ(IMax 0 1)` against `Succ(Succ Zero)`
-      -- structurally and the case-split paths can diverge.
       KExprNode.Srt(l) =>
         store(KExprNode.Srt(level_reduce(store(KLevelNode.Succ(l))))),
 
-      -- Mirror: src/ix/kernel/check.rs:110-120 universe-arity validation.
-      -- Validates `lvls.len() == num_lvls(ci)`.
-      KExprNode.Const(idx, lvls) =>
-        let ci = load(list_lookup(top, idx));
+      KExprNode.Const(addr, lvls) =>
+        let ci = load(get_ci(addr));
         let expected = const_num_lvls(ci);
         let given = list_length(lvls);
-        assert_eq!(given, expected);
+        assert_eq!(given, expected,
+          "Const applied to wrong number of universe levels");
         let ty = const_type_of(ci);
         expr_inst_levels(ty, lvls),
 
       KExprNode.App(_, _) =>
-        -- App-spine fusion: collect the entire spine, infer the head once,
-        -- then peel its Forall telescope arg-by-arg using a single
-        -- `expr_inst_many` per step on the ORIGINAL dom (with a growing
-        -- innermost-first subs list) instead of N consecutive `expr_inst1`
-        -- rewalks of a residual cod. Saves O(N) intermediate stored exprs
-        -- on heavily-applied terms.
         match collect_spine(e) {
           (head, args) =>
-            let head_ty = k_infer(head, types, top, addrs);
-            k_infer_app_spine_loop(head_ty, args, store(ListNode.Nil),
-                                    types, top, addrs),
+            let head_ty = k_infer(head, types);
+            k_infer_app_spine_loop(head_ty, args, store(ListNode.Nil), types),
         },
 
       KExprNode.Lam(ty, body) =>
-        k_ensure_sort(ty, types, top, addrs);
+        k_ensure_sort(ty, types);
         let types2 = store(ListNode.Cons(ty, types));
-        let body_ty = k_infer(body, types2, top, addrs);
+        let body_ty = k_infer(body, types2);
         store(KExprNode.Forall(ty, body_ty)),
 
       KExprNode.Forall(ty, body) =>
-        let u1 = k_ensure_sort(ty, types, top, addrs);
+        let u1 = k_ensure_sort(ty, types);
         let types2 = store(ListNode.Cons(ty, types));
-        let u2 = k_ensure_sort(body, types2, top, addrs);
+        let u2 = k_ensure_sort(body, types2);
         store(KExprNode.Srt(level_imax(u1, u2))),
 
-      KExprNode.Let(ty, val, body) => k_infer_let(ty, val, body, types, top, addrs),
-
-      KExprNode.Lit(lit) => k_infer_lit(lit, addrs),
-
-      KExprNode.Proj(tidx, fidx, e1) => k_infer_proj(tidx, fidx, e1, types, top, addrs),
-    }
-  }
-
-  -- Cold-extracted Let arm (same pattern as `expr_lbr_let`): four call
-  -- sites on a rare arm would otherwise widen every k_infer_core row.
-  fn k_infer_let(ty: KExpr, val: KExpr, body: KExpr, types: List‹KExpr›,
-                 top: List‹&KConstantInfo›, addrs: List‹Addr›) -> KExpr {
-    k_ensure_sort(ty, types, top, addrs);
-    k_check(val, ty, types, top, addrs);
-    let body_substed = expr_inst1(body, val, 0);
-    k_infer(body_substed, types, top, addrs)
-  }
-
-  -- Cold-extracted Lit arm.
-  fn k_infer_lit(lit: KLiteral, addrs: List‹Addr›) -> KExpr {
-    match lit {
-      KLiteral.Nat(_) => nat_const_type(addrs),
-      KLiteral.Str(_) => str_const_type(addrs),
-    }
-  }
+      KExprNode.Let(ty, val, body) =>
+        k_ensure_sort(ty, types);
+        k_check(val, ty, types);
+        let body_substed = expr_inst1(body, val, 0);
+        k_infer(body_substed, types),
 
-  -- Cold-extracted Proj arm: the widest arm of `k_infer_core` by far
-  -- (~10 call sites) on a rare node kind.
-  -- Mirror: src/ix/kernel/infer.rs:331-450 infer_proj.
-  fn k_infer_proj(tidx: G, fidx: G, e1: KExpr, types: List‹KExpr›,
-                  top: List‹&KConstantInfo›, addrs: List‹Addr›) -> KExpr {
-    let val_ty = k_infer(e1, types, top, addrs);
-    let wty = whnf(val_ty, types, top, addrs);
-    let pair = collect_spine(wty);
-    match pair {
-      (head, args) =>
-        match load(head) {
-          KExprNode.Const(idx, lvls) =>
-            assert_eq!(idx, tidx);
-            let ind_ci = load(list_lookup(top, idx));
-            match ind_ci {
-              KConstantInfo.Induct(_, ind_ty, n_params, n_indices, ctor_indices, _, _) =>
-                -- Single-ctor structure required.
-                assert_eq!(list_length(ctor_indices), 1);
-                let is_prop = is_inductive_prop(ind_ty, lvls, n_params + n_indices,
-                                                 types, top, addrs);
-                let ctor_idx = list_lookup(ctor_indices, 0);
-                let ctor_ci = load(list_lookup(top, ctor_idx));
-                match ctor_ci {
-                  KConstantInfo.Ctor(_, ctor_ty, _, _, _, _, _) =>
-                    let ctor_ty_inst = expr_inst_levels(ctor_ty, lvls);
-                    let after_params = peel_params_subst(ctor_ty_inst, args, n_params);
-                    peel_field_loop(after_params, fidx, 0, tidx, e1, is_prop,
-                                    types, top, addrs),
-                },
-            },
-        },
+      --  handlers:
+      KExprNode.Lit(lit) => k_infer_lit(lit),
+      KExprNode.Proj(struct_addr, fidx, e1) =>
+        k_infer_proj(struct_addr, fidx, e1, types),
     }
   }
 
@@ -176,369 +124,694 @@ def infer := ⟦
   -- not a residual) for the check, then descend into `cod` with the
   -- extended subs. At spine end, one final expr_inst_many on the remaining
   -- `cod` yields the result type.
-  --
   -- When `load(t)` isn't a Forall, materialise via whnf on the concretised
   -- t (= prior subs applied to original t). Post-whnf dom/cod are in the
   -- OUTER context, so we restart the descent with subs_rev = [a].
   fn k_infer_app_spine_loop(t: KExpr, args: List‹KExpr›,
-                             subs_rev: List‹KExpr›,
-                             types: List‹KExpr›,
-                             top: List‹&KConstantInfo›,
-                             addrs: List‹Addr›) -> KExpr {
+                                subs_rev: List‹KExpr›,
+                                types: List‹KExpr›) -> KExpr {
     match load(args) {
-      ListNode.Nil => expr_inst_many(t, subs_rev, 0),
+      ListNode.Nil =>
+        match list_length(subs_rev) {
+          0 => t,
+          _ => expr_inst_many(t, subs_rev, 0),
+        },
       ListNode.Cons(a, rest) =>
         match load(t) {
           KExprNode.Forall(dom, cod) =>
-            let concrete_dom = expr_inst_many(dom, subs_rev, 0);
-            k_check(a, concrete_dom, types, top, addrs);
-            let new_subs = store(ListNode.Cons(a, subs_rev));
-            k_infer_app_spine_loop(cod, rest, new_subs, types, top, addrs),
+            let dom_subst = match list_length(subs_rev) {
+              0 => dom,
+              _ => expr_inst_many(dom, subs_rev, 0),
+            };
+            k_check(a, dom_subst, types);
+            k_infer_app_spine_loop(cod, rest,
+              store(ListNode.Cons(a, subs_rev)), types),
           _ =>
-            let t_concrete = expr_inst_many(t, subs_rev, 0);
-            let t_whnf = whnf(t_concrete, types, top, addrs);
-            let triple = ensure_forall_post_whnf(t_whnf);
-            match triple {
-              (ok, dom, cod) =>
-                assert_eq!(ok, 1);
-                k_check(a, dom, types, top, addrs);
-                let new_subs = store(ListNode.Cons(a, store(ListNode.Nil)));
-                k_infer_app_spine_loop(cod, rest, new_subs, types, top, addrs),
+            let t_concrete = match list_length(subs_rev) {
+              0 => t,
+              _ => expr_inst_many(t, subs_rev, 0),
+            };
+            let t_w = whnf(t_concrete, types);
+            match load(t_w) {
+              KExprNode.Forall(dom, cod) =>
+                k_check(a, dom, types);
+                k_infer_app_spine_loop(cod, rest,
+                  store(ListNode.Cons(a, store(ListNode.Nil))), types),
             },
         },
     }
   }
 
-  fn k_ensure_sort(e: KExpr, types: List‹KExpr›,
-                   top: List‹&KConstantInfo›, addrs: List‹Addr›) -> KLevel {
-    let ty = k_infer(e, types, top, addrs);
-    -- Mirror: src/ix/kernel/infer.rs:454-478 syntactic Sort fast-path.
-    match load(ty) {
-      KExprNode.Srt(l) => l,
-      _ =>
-        let ty_whnf = whnf(ty, types, top, addrs);
-        let pair = ensure_sort_post_whnf(ty_whnf);
-        match pair {
-          (ok, l) =>
-            assert_eq!(ok, 1);
-            l,
-        },
-    }
+  -- Canonical primitive addrs (Nat / String). Mirrors
+  -- Ix.IxVM.Kernel.Primitive::nat_addr / str_addr — content-hashes
+  -- of the primitive constants' Ixon serializations.
+  fn nat_addr() -> Addr {
+    store([0x39u8, 0x8au8, 0x77u8, 0x06u8, 0xcfu8, 0x13u8, 0xf2u8, 0x23u8,
+     0x99u8, 0x2du8, 0x17u8, 0x3du8, 0xceu8, 0x07u8, 0x94u8, 0x68u8,
+     0x57u8, 0x24u8, 0x0fu8, 0x49u8, 0xafu8, 0xccu8, 0x74u8, 0x37u8,
+     0x23u8, 0xe8u8, 0x39u8, 0xf8u8, 0xf3u8, 0xf2u8, 0xb6u8, 0x31u8])
   }
 
-  -- Mirror: src/ix/kernel/infer.rs App-arg / Let-val pattern. Infer e's
-  -- type and compare against expected via k_is_def_eq. Mismatch panics.
-  fn k_check(e: KExpr, expected: KExpr, types: List‹KExpr›,
-             top: List‹&KConstantInfo›, addrs: List‹Addr›) {
-    let inferred = k_infer(e, types, top, addrs);
-    let eq = k_is_def_eq(inferred, expected, types, top, addrs);
-    assert_eq!(eq, 1);
+  fn str_addr() -> Addr {
+    store([0x7au8, 0xb2u8, 0xd5u8, 0x2au8, 0xc5u8, 0x2fu8, 0xd1u8, 0xf5u8,
+     0x18u8, 0x09u8, 0xb7u8, 0x18u8, 0xe5u8, 0x3cu8, 0xd0u8, 0x58u8,
+     0xacu8, 0x4bu8, 0x50u8, 0xd6u8, 0x51u8, 0x50u8, 0xe7u8, 0x8au8,
+     0xe6u8, 0x19u8, 0x13u8, 0x9cu8, 0xcfu8, 0x13u8, 0xc8u8, 0xfdu8])
   }
 
-  -- ============================================================================
-  -- k_infer_only: type-synthesis-only (mirror Rust `with_infer_only`).
-  -- Skips inner validations: App drops `k_check(a, dom)`; Lam drops
-  -- `k_ensure_sort(ty)`; Let drops val/ty checks. Distinct Aiur memo from
-  -- `k_infer` (parity with Rust's separate infer_cache / infer_only_cache).
-  -- Used at try_proof_irrel / is_prop_type / try_unit_like where only the
-  -- synthesized type is needed.
-  --
-  -- ## Safety invariant
-  --
-  -- `k_infer_only` is NOT safe to call on an arbitrary term — only on terms
-  -- already known to be well-typed (i.e., terms that would have passed
-  -- `k_infer`). The reason: our overall invariant is that evaluation only
-  -- happens after typechecking. `k_infer_only` evaluates types (e.g. the
-  -- substitution `B[a/x]` on an `App` arm) WITHOUT first checking that the
-  -- substituted-in argument `a` has the proper type (the dropped
-  -- `k_check(a, dom)`). On an untyped or ill-typed term, that substitution
-  -- can take us out of the well-typed fragment, after which subsequent
-  -- `whnf` / `def_eq` work is unsound.
-  --
-  -- The current call sites (`try_proof_irrel`, `is_prop_type`,
-  -- `try_unit_like`) honor this invariant because they hand `k_infer_only`
-  -- a term obtained by `whnf`-ing a well-typed input. `whnf` of a
-  -- well-typed term yields a structurally different but still well-typed
-  -- term, so the no-checks shortcut is sound there even though the result
-  -- term itself was never the direct subject of `k_infer`.
-  --
-  -- ## Future: shared memo via non-deterministic hint
-  --
-  -- `k_infer_only`'s separate memo (parity with Rust) means an `infer_only`
-  -- call cannot reuse an existing `k_infer` hit on the same input. A
-  -- planned improvement: at each `try_proof_irrel` / `try_unit_like` site,
-  -- the prover supplies a hint `enum Hint { None, KInfer, KInferOnly }`:
-  --   1. `None`         — term is not unit-like and not a proof; skip both
-  --                       and fall through to deep `def_eq`.
-  --   2. `KInfer`       — `k_infer`'s memo is a hit on this input; call
-  --                       `k_infer` (cheap, reuses the cached row) and
-  --                       check the result is a proof / unit-like.
-  --   3. `KInferOnly`   — `k_infer`'s memo would miss; call `k_infer_only`
-  --                       (cheaper than a fresh `k_infer`) and check.
-  -- Dispatching on the hint with a `match` lets us share `k_infer`'s memo
-  -- where available and fall back to `k_infer_only` only when the cheaper
-  -- path won't pay off, instead of unconditionally paying the parallel
-  -- `infer_only` memo cost.
-  -- ============================================================================
-  fn k_infer_only(e: KExpr, types: List‹KExpr›,
-                  top: List‹&KConstantInfo›, addrs: List‹Addr›) -> KExpr {
-    k_infer_only_core(e, ctx_trim(types, expr_lbr(e)), top, addrs)
+  fn k_infer_lit(lit: KLiteral) -> KExpr {
+    match lit {
+      KLiteral.Nat(_) => store(KExprNode.Const(nat_addr(), store(ListNode.Nil))),
+      KLiteral.Str(_) => store(KExprNode.Const(str_addr(), store(ListNode.Nil))),
+    }
   }
 
-  fn k_infer_only_core(e: KExpr, types: List‹KExpr›,
-                       top: List‹&KConstantInfo›, addrs: List‹Addr›) -> KExpr {
-    match load(e) {
-      KExprNode.BVar(i) => types_lookup(types, i),
-      KExprNode.Srt(l) =>
-        store(KExprNode.Srt(level_reduce(store(KLevelNode.Succ(l))))),
-      KExprNode.Const(idx, lvls) =>
-        let ci = load(list_lookup(top, idx));
-        let expected = const_num_lvls(ci);
-        let given = list_length(lvls);
-        assert_eq!(given, expected);
-        let ty = const_type_of(ci);
-        expr_inst_levels(ty, lvls),
-      KExprNode.App(f, a) =>
-        let f_ty = k_infer_only(f, types, top, addrs);
-        match load(f_ty) {
-          KExprNode.Forall(_, cod) => expr_inst1(cod, a, 0),
-          _ =>
-            let f_ty_whnf = whnf(f_ty, types, top, addrs);
-            let triple = ensure_forall_post_whnf(f_ty_whnf);
-            match triple {
-              (ok, _, cod) =>
-                assert_eq!(ok, 1);
-                expr_inst1(cod, a, 0),
-            },
-        },
-      KExprNode.Lam(ty, body) =>
-        let types2 = store(ListNode.Cons(ty, types));
-        let body_ty = k_infer_only(body, types2, top, addrs);
-        store(KExprNode.Forall(ty, body_ty)),
-      KExprNode.Forall(ty, body) =>
-        let u1 = k_ensure_sort_only(ty, types, top, addrs);
-        let types2 = store(ListNode.Cons(ty, types));
-        let u2 = k_ensure_sort_only(body, types2, top, addrs);
-        store(KExprNode.Srt(level_imax(u1, u2))),
-      KExprNode.Let(_, val, body) =>
-        let body_substed = expr_inst1(body, val, 0);
-        k_infer_only(body_substed, types, top, addrs),
-      KExprNode.Lit(lit) =>
-        match lit {
-          KLiteral.Nat(_) => nat_const_type(addrs),
-          KLiteral.Str(_) => str_const_type(addrs),
-        },
-      KExprNode.Proj(tidx, fidx, e1) =>
-        let val_ty = k_infer_only(e1, types, top, addrs);
-        let wty = whnf(val_ty, types, top, addrs);
-        let pair = collect_spine(wty);
-        match pair {
-          (head, args) =>
-            match load(head) {
-              KExprNode.Const(idx, lvls) =>
-                assert_eq!(idx, tidx);
-                let ind_ci = load(list_lookup(top, idx));
-                match ind_ci {
-                  KConstantInfo.Induct(_, ind_ty, n_params, n_indices, ctor_indices, _, _) =>
-                    assert_eq!(list_length(ctor_indices), 1);
-                    let is_prop = is_inductive_prop(ind_ty, lvls, n_params + n_indices,
-                                                     types, top, addrs);
-                    let ctor_idx = list_lookup(ctor_indices, 0);
-                    let ctor_ci = load(list_lookup(top, ctor_idx));
-                    match ctor_ci {
-                      KConstantInfo.Ctor(_, ctor_ty, _, _, _, _, _) =>
-                        let ctor_ty_inst = expr_inst_levels(ctor_ty, lvls);
-                        let after_params = peel_params_subst(ctor_ty_inst, args, n_params);
-                        peel_field_loop(after_params, fidx, 0, tidx, e1, is_prop,
-                                        types, top, addrs),
-                    },
-                },
+  -- Peel `n_params` Foralls, substituting each with args[i].
+  fn peel_params_subst(ty: KExpr, args: List‹KExpr›, n_params: G) -> KExpr {
+    match n_params {
+      0 => ty,
+      _ =>
+        match load(ty) {
+          KExprNode.Forall(_, body) =>
+            match load(args) {
+              ListNode.Cons(arg, rest) =>
+                let body_substed = expr_inst1(body, arg, 0);
+                peel_params_subst(body_substed, rest, n_params - 1),
             },
         },
     }
   }
 
-  fn k_ensure_sort_only(e: KExpr, types: List‹KExpr›,
-                        top: List‹&KConstantInfo›, addrs: List‹Addr›) -> KLevel {
-    let ty = k_infer_only(e, types, top, addrs);
-    match load(ty) {
-      KExprNode.Srt(l) => l,
-      _ =>
-        let ty_whnf = whnf(ty, types, top, addrs);
-        let pair = ensure_sort_post_whnf(ty_whnf);
-        match pair {
-          (ok, l) =>
-            assert_eq!(ok, 1);
-            l,
-        },
+  -- Walk ctor type's field foralls, substituting Proj(struct_addr, i, val)
+  -- for each preceding field. At target field, return its dom.
+  -- 1 iff the inductive's type, after peeling params+indices, lands in
+  -- Sort 0. Mirror is_inductive_prop (Infer.lean:493).
+  fn is_inductive_prop(ind_ty: KExpr, lvls: List‹KLevel›, n_skip: G,
+                            types: List‹KExpr›) -> G {
+    let ind_ty_inst = expr_inst_levels(ind_ty, lvls);
+    let result = peel_n_alls_whnf(ind_ty_inst, n_skip, types);
+    match load(result) {
+      KExprNode.Srt(l) => level_equal(l, store(KLevelNode.Zero)),
+      _ => 0,
     }
   }
 
-  -- ============================================================================
-  -- Helpers: extract const declared type, Nat/Str literal types.
-  -- ============================================================================
-  fn const_type_of(ci: KConstantInfo) -> KExpr {
-    match ci {
-      KConstantInfo.Axiom(_, ty, _) => ty,
-      KConstantInfo.Defn(_, ty, _, _, _) => ty,
-      KConstantInfo.Thm(_, ty, _) => ty,
-      KConstantInfo.Opaque(_, ty, _, _) => ty,
-      KConstantInfo.Quot(_, ty, _) => ty,
-      KConstantInfo.Induct(_, ty, _, _, _, _, _) => ty,
-      KConstantInfo.Ctor(_, ty, _, _, _, _, _) => ty,
-      KConstantInfo.Rec(_, ty, _, _, _, _, _, _, _, _) => ty,
+  -- Peel `n` Foralls, calling `whnf` on each step. Returns the whnf'd body.
+  fn peel_n_alls_whnf(e: KExpr, n: G, types: List‹KExpr›) -> KExpr {
+    match n {
+      0 => whnf(e, types),
+      _ =>
+        let ew = whnf(e, types);
+        match load(ew) {
+          KExprNode.Forall(dom, body) =>
+            let t2 = store(ListNode.Cons(dom, types));
+            peel_n_alls_whnf(body, n - 1, t2),
+          _ => ew,
+        },
     }
   }
 
-  -- Mirror: each KConstantInfo carries num_lvls as its first G field.
-  fn const_num_lvls(ci: KConstantInfo) -> G {
-    match ci {
-      KConstantInfo.Axiom(n, _, _) => n,
-      KConstantInfo.Defn(n, _, _, _, _) => n,
-      KConstantInfo.Thm(n, _, _) => n,
-      KConstantInfo.Opaque(n, _, _, _) => n,
-      KConstantInfo.Quot(n, _, _) => n,
-      KConstantInfo.Induct(n, _, _, _, _, _, _) => n,
-      KConstantInfo.Ctor(n, _, _, _, _, _, _) => n,
-      KConstantInfo.Rec(n, _, _, _, _, _, _, _, _, _) => n,
+  -- Prop-structure projection gates (mirror Infer.lean:507 / :457).
+  -- Projecting out of a Prop-valued structure would extract data from a
+  -- proof, breaking proof irrelevance. Two rules, both only for
+  -- `is_prop` structures:
+  --   * the TARGET field must itself be a Prop (Sort 0);
+  --   * any data field skipped on the way must not be depended on by
+  --     the remaining telescope (no loose bvars in the body).
+  fn check_prop_field_if_prop(is_prop: G, dom: KExpr,
+                                   types: List‹KExpr›) {
+    match is_prop {
+      0 => (),
+      _ =>
+        let lvl = k_ensure_sort(dom, types);
+        assert_eq!(level_equal(lvl, store(KLevelNode.Zero)), 1,
+          "projection on a Prop structure: field is not a Prop");
+        (),
     }
   }
 
-  -- Mirror: peel n_params Foralls off ctor_ty, substituting each
-  -- bound var with the corresponding `args[i]`. Used by infer_proj.
-  fn peel_params_subst(ty: KExpr, args: List‹KExpr›, n_params: G) -> KExpr {
-    match n_params {
-      0 => ty,
+  -- Mirror crates/kernel/src/infer.rs dependent-data-field guard.
+  -- For Prop structures: a preceding data field (sort != 0) whose body
+  -- has any loose bvar (`body.lbr() > 0`) makes projection past it unsound.
+  -- Matches Rust's `body.lbr() > 0` check exactly.
+  fn check_no_dep_data_field_if_prop(is_prop: G, dom: KExpr, body: KExpr,
+                                          types: List‹KExpr›) {
+    match is_prop {
+      0 => (),
       _ =>
-        match load(ty) {
-          KExprNode.Forall(_, body) =>
-            match load(args) {
-              ListNode.Cons(arg, rest) =>
-                let body_substed = expr_inst1(body, arg, 0);
-                peel_params_subst(body_substed, rest, n_params - 1),
-            },
+        let lvl = k_ensure_sort(dom, types);
+        match level_equal(lvl, store(KLevelNode.Zero)) {
+          1 => (),
+          _ =>
+            -- data field: the rest of the telescope must not depend on it.
+            assert_eq!(expr_lbr(body), 0,
+              "projection on a Prop structure: later fields depend on a data field");
+            (),
         },
     }
   }
 
-  -- Mirror: src/ix/kernel/infer.rs:414-449 ctor-field walk loop.
+  -- Mirror crates/kernel/src/infer.rs ctor-field walk loop.
   -- For each preceding field i < target_field, substitute body[Var(0)
   -- := Proj(struct_idx, i, val)] before recursing. At i == target_field,
   -- return the field's domain type.
-  --
   -- For Prop structures (`is_prop == 1`), enforce two soundness checks:
-  --   (a) preceding data field whose body depends on BVar(0) is forbidden
-  --       (no projection past dependent data fields, mirror Rust line 433-444);
-  --   (b) projected (target) field must itself be in Prop (mirror Rust line 418-427).
-  fn peel_field_loop(ty: KExpr, target_field: G, current: G,
-                     struct_idx: G, val: KExpr, is_prop: G,
-                     types: List‹KExpr›, top: List‹&KConstantInfo›,
-                     addrs: List‹Addr›) -> KExpr {
+  -- (a) preceding data field whose body depends on BVar(0) is forbidden
+  -- (no projection past dependent data fields, mirror Rust line 433-444);
+  -- (b) projected (target) field must itself be in Prop (mirror Rust line 418-427).
+  fn peel_field_loop(ty: KExpr, target: G, current: G,
+                         struct_addr: Addr, val: KExpr, is_prop: G,
+                         types: List‹KExpr›) -> KExpr {
     match load(ty) {
       KExprNode.Forall(dom, body) =>
-        match target_field - current {
+        match target - current {
           0 =>
-            check_prop_field_if_prop(is_prop, dom, types, top, addrs);
+            check_prop_field_if_prop(is_prop, dom, types);
             dom,
           _ =>
-            check_no_dep_data_field_if_prop(is_prop, dom, body, types, top, addrs);
-            let proj_expr = store(KExprNode.Proj(struct_idx, current, val));
+            check_no_dep_data_field_if_prop(is_prop, dom, body, types);
+            let proj_expr = store(KExprNode.Proj(struct_addr, current, val));
             let body_substed = expr_inst1(body, proj_expr, 0);
-            peel_field_loop(body_substed, target_field, current + 1,
-              struct_idx, val, is_prop, types, top, addrs),
+            peel_field_loop(body_substed, target, current + 1,
+                                 struct_addr, val, is_prop, types),
         },
     }
   }
 
-  -- Mirror: src/ix/kernel/infer.rs:431-444 dependent-data-field guard.
-  -- For Prop structures: a preceding data field (sort != 0) whose body
-  -- has any loose bvar (`body.lbr() > 0`) makes projection past it unsound.
-  -- Matches Rust's `body.lbr() > 0` check exactly.
-  fn check_no_dep_data_field_if_prop(is_prop: G, dom: KExpr, body: KExpr,
-                                       types: List‹KExpr›,
-                                       top: List‹&KConstantInfo›,
-                                       addrs: List‹Addr›) {
-    match is_prop {
-      0 => (),
+  -- Cold-extracted Proj arm: the widest arm of `k_infer_core` by far
+  -- (~10 call sites) on a rare node kind.
+  -- Mirror crates/kernel/src/infer.rs infer_proj.
+  fn k_infer_proj(struct_addr: Addr, fidx: G, e1: KExpr,
+                      types: List‹KExpr›) -> KExpr {
+    let val_ty = k_infer(e1, types);
+    let wty = whnf(val_ty, types);
+    match collect_spine(wty) {
+      (head, args) =>
+        match load(head) {
+          KExprNode.Const(head_addr, lvls) =>
+            assert_eq!(ptr_val(head_addr), ptr_val(struct_addr),
+              "projection's structure type differs from the value's head");
+            let ind_ci = load(get_ci(head_addr));
+            match ind_ci {
+              KConstantInfo.Induct(_, ind_ty, n_params, n_indices, num_ctors, _,
+                                     block_addr, ind_idx) =>
+                -- A projection is only meaningful on a structure: exactly one
+                -- constructor, so field `fidx` names an unambiguous field and
+                -- cidx=0 is the only choice. Without this a Proj on a
+                -- multi-ctor inductive silently reads ctor 0's field types
+                -- off a value built by a different ctor.
+                assert_eq!(num_ctors, 1,
+                  "projection on an inductive with more than one constructor");
+                let ctor_ci = load(get_ci_cprj(block_addr, ind_idx, 0));
+                match ctor_ci {
+                  KConstantInfo.Ctor(_, ctor_ty, _, _, _, _, _, _) =>
+                    let ctor_ty_inst = expr_inst_levels(ctor_ty, lvls);
+                    let after_params = peel_params_subst(ctor_ty_inst, args, n_params);
+                    -- Prop-valued structures get the projection gates.
+                    let is_prop = is_inductive_prop(ind_ty, lvls,
+                                    n_params + n_indices, types);
+                    peel_field_loop(after_params, fidx, 0,
+                                         struct_addr, e1, is_prop, types),
+                },
+            },
+        },
+    }
+  }
+
+  fn k_ensure_sort(e: KExpr, types: List‹KExpr›) -> KLevel {
+    let t = k_infer(e, types);
+    let tw = whnf(t, types);
+    match load(tw) {
+      KExprNode.Srt(l) => l,
+    }
+  }
+
+  -- Check: infer the expr's type, def-eq against expected.
+  fn k_check(e: KExpr, expected: KExpr, types: List‹KExpr›) {
+    let inferred = k_infer(e, types);
+    let d = k_is_def_eq(inferred, expected, types);
+    assert_eq!(d, 1, "inferred type is not def-eq to the expected type");
+  }
+
+  -- ============================================================================
+  -- Decidable dispatch.
+  --
+  -- Handles `Nat.decLe`/`Nat.decLt`/`Nat.decEq` on literal args. Builds
+  -- `Decidable.isTrue prop proof` / `Decidable.isFalse prop proof` with
+  -- compiler-emitted witness helpers. `prop` recovered via k_infer on the
+  -- (head, arg0, arg1) call expression under the current types context.
+  -- ============================================================================
+
+  fn nat_dec_le_addr_dec() -> Addr {
+    store([0xecu8, 0x1fu8, 0x60u8, 0xc1u8, 0xa2u8, 0x8du8, 0x48u8, 0xbcu8,
+     0x98u8, 0xfeu8, 0x3eu8, 0xf7u8, 0x2du8, 0x25u8, 0x51u8, 0x32u8,
+     0x73u8, 0x5au8, 0x50u8, 0x3cu8, 0xc3u8, 0x6eu8, 0x3fu8, 0xf0u8,
+     0xf2u8, 0x2eu8, 0x3du8, 0x48u8, 0x6eu8, 0x26u8, 0x6eu8, 0xbeu8])
+  }
+
+  fn nat_dec_eq_addr_dec() -> Addr {
+    store([0xb4u8, 0xb2u8, 0x6cu8, 0x2eu8, 0x29u8, 0x93u8, 0x1cu8, 0x06u8,
+     0xe8u8, 0x85u8, 0x91u8, 0x46u8, 0x13u8, 0xfau8, 0xffu8, 0x58u8,
+     0x56u8, 0x13u8, 0x8eu8, 0x5cu8, 0xb0u8, 0x96u8, 0x20u8, 0xddu8,
+     0xb6u8, 0x92u8, 0x1au8, 0x34u8, 0x2du8, 0xedu8, 0x89u8, 0x57u8])
+  }
+
+  fn nat_dec_lt_addr_dec() -> Addr {
+    store([0xc0u8, 0x13u8, 0xc1u8, 0x53u8, 0xebu8, 0xf0u8, 0x20u8, 0x28u8,
+     0xaeu8, 0xd2u8, 0x64u8, 0x33u8, 0x3cu8, 0x1eu8, 0x4cu8, 0x85u8,
+     0x01u8, 0x7du8, 0x0bu8, 0x87u8, 0x02u8, 0x5du8, 0x75u8, 0x96u8,
+     0xa9u8, 0x69u8, 0x71u8, 0xbbu8, 0x2bu8, 0x67u8, 0x92u8, 0x1du8])
+  }
+
+  fn decidable_is_true_addr_dec() -> Addr {
+    store([0x0fu8, 0x9eu8, 0xe8u8, 0xd9u8, 0x03u8, 0x3du8, 0x8fu8, 0x7bu8,
+     0x85u8, 0x2fu8, 0x5bu8, 0x71u8, 0x52u8, 0xfdu8, 0x12u8, 0x4fu8,
+     0x7du8, 0x41u8, 0x19u8, 0x30u8, 0xc9u8, 0x92u8, 0xe0u8, 0xf4u8,
+     0x57u8, 0xf8u8, 0x10u8, 0x4bu8, 0x60u8, 0xa9u8, 0x83u8, 0x81u8])
+  }
+
+  fn decidable_is_false_addr_dec() -> Addr {
+    store([0x04u8, 0x71u8, 0xe4u8, 0x71u8, 0x58u8, 0xb2u8, 0xaeu8, 0x18u8,
+     0xd3u8, 0xc0u8, 0x8du8, 0xd5u8, 0xc7u8, 0x7au8, 0xaeu8, 0x23u8,
+     0xe6u8, 0x2du8, 0x7bu8, 0xbcu8, 0x1eu8, 0x61u8, 0x11u8, 0x6bu8,
+     0xc2u8, 0x81u8, 0x3bu8, 0x13u8, 0x06u8, 0xbcu8, 0x57u8, 0x95u8])
+  }
+
+  fn nat_le_of_ble_eq_true_addr_dec() -> Addr {
+    store([0x21u8, 0xe0u8, 0xe0u8, 0x78u8, 0x3bu8, 0x76u8, 0x17u8, 0xb0u8,
+     0xccu8, 0x4eu8, 0xffu8, 0x4du8, 0x1fu8, 0xabu8, 0x7cu8, 0xffu8,
+     0xefu8, 0xe0u8, 0x1cu8, 0xd4u8, 0x3du8, 0xa7u8, 0x7eu8, 0x2fu8,
+     0x98u8, 0xd1u8, 0x50u8, 0x94u8, 0xa0u8, 0xd8u8, 0xf0u8, 0x86u8])
+  }
+
+  fn nat_not_le_of_not_ble_eq_true_addr_dec() -> Addr {
+    store([0x01u8, 0x83u8, 0x59u8, 0x5bu8, 0x83u8, 0x7bu8, 0x9bu8, 0x84u8,
+     0xdau8, 0x5fu8, 0x00u8, 0x4bu8, 0x8au8, 0xc4u8, 0xa4u8, 0xbbu8,
+     0xd3u8, 0xbcu8, 0x06u8, 0x28u8, 0xb9u8, 0x9cu8, 0x8du8, 0x55u8,
+     0x0eu8, 0xb3u8, 0x51u8, 0xf7u8, 0x4cu8, 0xe1u8, 0x6du8, 0x48u8])
+  }
+
+  fn nat_eq_of_beq_eq_true_addr_dec() -> Addr {
+    store([0x9cu8, 0xe6u8, 0xe3u8, 0x22u8, 0xf1u8, 0x94u8, 0x81u8, 0xf2u8,
+     0x1cu8, 0xf4u8, 0xc4u8, 0x8fu8, 0x88u8, 0x78u8, 0x98u8, 0x76u8,
+     0xb6u8, 0x9bu8, 0x8au8, 0x9bu8, 0x15u8, 0x20u8, 0x43u8, 0x9cu8,
+     0x10u8, 0x1du8, 0x98u8, 0x3fu8, 0x96u8, 0xeau8, 0x60u8, 0xb7u8])
+  }
+
+  fn nat_ne_of_beq_eq_false_addr_dec() -> Addr {
+    store([0x3cu8, 0xf5u8, 0x4du8, 0x33u8, 0x38u8, 0x21u8, 0xddu8, 0x37u8,
+     0x68u8, 0x3au8, 0x0bu8, 0xf3u8, 0x87u8, 0x39u8, 0xe6u8, 0x87u8,
+     0x61u8, 0x0au8, 0x19u8, 0x91u8, 0x75u8, 0x92u8, 0x20u8, 0xb7u8,
+     0x7eu8, 0xdeu8, 0xc3u8, 0x38u8, 0xbau8, 0x3cu8, 0xfbu8, 0xc8u8])
+  }
+
+  fn bool_type_addr_dec() -> Addr {
+    store([0xe6u8, 0xebu8, 0xa3u8, 0xc8u8, 0xb4u8, 0xd1u8, 0x9fu8, 0x6au8,
+     0x10u8, 0x76u8, 0xb3u8, 0x9fu8, 0xa8u8, 0x9au8, 0xecu8, 0x61u8,
+     0xdcu8, 0xcbu8, 0xb9u8, 0x60u8, 0xf8u8, 0x3du8, 0x9au8, 0x62u8,
+     0xe6u8, 0xacu8, 0xf3u8, 0x5au8, 0x69u8, 0xc9u8, 0xa0u8, 0xa4u8])
+  }
+
+  fn eq_refl_addr_dec() -> Addr {
+    store([0x6cu8, 0x9bu8, 0xd6u8, 0x0eu8, 0x1eu8, 0xaeu8, 0x93u8, 0x8eu8,
+     0x56u8, 0x26u8, 0xcau8, 0x23u8, 0x7du8, 0xbcu8, 0xa7u8, 0xfdu8,
+     0x95u8, 0x0fu8, 0x2eu8, 0x99u8, 0xe2u8, 0x34u8, 0xa9u8, 0x9cu8,
+     0x23u8, 0xcfu8, 0xdcu8, 0x29u8, 0x4cu8, 0xa7u8, 0xadu8, 0xceu8])
+  }
+
+  fn int_dec_eq_addr_dec() -> Addr {
+    store([0x83u8, 0xfdu8, 0xe3u8, 0x8fu8, 0xaau8, 0x11u8, 0x64u8, 0x64u8,
+     0x8eu8, 0x42u8, 0x27u8, 0x97u8, 0x5au8, 0xbfu8, 0x2eu8, 0x8cu8,
+     0x26u8, 0x0du8, 0x7du8, 0x4eu8, 0xf1u8, 0xc9u8, 0x26u8, 0x76u8,
+     0x21u8, 0x4fu8, 0xfeu8, 0x58u8, 0x26u8, 0xc2u8, 0x07u8, 0x5du8])
+  }
+
+  fn int_dec_le_addr_dec() -> Addr {
+    store([0x38u8, 0xd6u8, 0x0fu8, 0xfau8, 0x07u8, 0xb5u8, 0x06u8, 0x78u8,
+     0xd0u8, 0xc3u8, 0xbfu8, 0x0cu8, 0x06u8, 0xf8u8, 0x6cu8, 0xd7u8,
+     0x96u8, 0x7bu8, 0x35u8, 0xe8u8, 0x7au8, 0xb0u8, 0x71u8, 0xbcu8,
+     0x55u8, 0x89u8, 0x9fu8, 0xcbu8, 0xaeu8, 0xd4u8, 0x74u8, 0x4fu8])
+  }
+
+  fn int_dec_lt_addr_dec() -> Addr {
+    store([0x55u8, 0x68u8, 0xe7u8, 0x99u8, 0x19u8, 0x8du8, 0xadu8, 0x9fu8,
+     0xabu8, 0x0eu8, 0x78u8, 0x4bu8, 0x7au8, 0x4cu8, 0x58u8, 0x11u8,
+     0x2bu8, 0xfcu8, 0x26u8, 0x88u8, 0xaeu8, 0xceu8, 0xbeu8, 0x3cu8,
+     0x2cu8, 0x65u8, 0x63u8, 0x30u8, 0x42u8, 0x10u8, 0xf9u8, 0x56u8])
+  }
+
+  fn int_of_nat_addr_dec() -> Addr {
+    store([0x09u8, 0xbcu8, 0x25u8, 0x31u8, 0x47u8, 0xc3u8, 0x6cu8, 0xe2u8,
+     0x2cu8, 0x8eu8, 0x0cu8, 0xcdu8, 0x43u8, 0xc7u8, 0x9bu8, 0x2cu8,
+     0xdau8, 0xe2u8, 0x20u8, 0x6eu8, 0x0du8, 0xddu8, 0x16u8, 0x8fu8,
+     0xcau8, 0x36u8, 0x09u8, 0xb2u8, 0xa5u8, 0x84u8, 0xd3u8, 0xdcu8])
+  }
+
+  fn int_neg_succ_addr_dec() -> Addr {
+    store([0x26u8, 0x7cu8, 0x0au8, 0x9cu8, 0x92u8, 0xe7u8, 0x56u8, 0x38u8,
+     0xfcu8, 0x73u8, 0xedu8, 0x52u8, 0xa9u8, 0xf9u8, 0xc8u8, 0x16u8,
+     0x47u8, 0xeeu8, 0xecu8, 0xeeu8, 0xffu8, 0x21u8, 0x44u8, 0xc1u8,
+     0xf9u8, 0x7eu8, 0x65u8, 0xe2u8, 0xafu8, 0xf1u8, 0x49u8, 0xf1u8])
+  }
+
+  fn is_dec_prim_addr(a: Addr) -> G {
+    match address_eq(a, nat_dec_le_addr_dec()) {
+      1 => 1,
       _ =>
-        let lvl = k_ensure_sort(dom, types, top, addrs);
-        match level_equal(lvl, store(KLevelNode.Zero)) {
-          1 => (),
+      match address_eq(a, nat_dec_eq_addr_dec()) {
+        1 => 1,
+        _ =>
+        match address_eq(a, nat_dec_lt_addr_dec()) {
+          1 => 1,
           _ =>
-            -- data field; body must have no loose bvars.
-            assert_eq!(expr_lbr(body), 0);
-            (),
+          match address_eq(a, int_dec_le_addr_dec()) {
+            1 => 1,
+            _ =>
+            match address_eq(a, int_dec_eq_addr_dec()) {
+              1 => 1,
+              _ =>
+              match address_eq(a, int_dec_lt_addr_dec()) {
+                1 => 1,
+                _ => 0,
+              },
+            },
+          },
         },
+      },
     }
   }
 
-  -- Peel `n` Foralls, calling `whnf` on each step. Returns the whnf'd body.
-  fn peel_n_alls_whnf(e: KExpr, n: G, types: List‹KExpr›,
-                      top: List‹&KConstantInfo›, addrs: List‹Addr›) -> KExpr {
-    match n {
-      0 => whnf(e, types, top, addrs),
+  fn is_int_dec_prim_addr(a: Addr) -> G {
+    match address_eq(a, int_dec_le_addr_dec()) {
+      1 => 1,
       _ =>
-        let ew = whnf(e, types, top, addrs);
-        match load(ew) {
-          KExprNode.Forall(_, body) =>
-            peel_n_alls_whnf(body, n - 1, types, top, addrs),
-          _ => ew,
+      match address_eq(a, int_dec_eq_addr_dec()) {
+        1 => 1,
+        _ =>
+        match address_eq(a, int_dec_lt_addr_dec()) {
+          1 => 1,
+          _ => 0,
         },
+      },
     }
   }
 
-  -- Mirror: src/ix/kernel/infer.rs:488-520 inductive_app_is_prop.
-  -- Returns 1 iff the inductive lives in Prop (peeled past params + indices,
-  -- result sort = Zero).
-  fn is_inductive_prop(ind_ty: KExpr, lvls: List‹KLevel›, n_skip: G,
-                       types: List‹KExpr›, top: List‹&KConstantInfo›,
-                       addrs: List‹Addr›) -> G {
-    let ind_ty_inst = expr_inst_levels(ind_ty, lvls);
-    let result = peel_n_alls_whnf(ind_ty_inst, n_skip, types, top, addrs);
-    match load(result) {
-      KExprNode.Srt(l) => level_equal(l, store(KLevelNode.Zero)),
-      _ => 0,
+  -- Match `App(Const(int_of_nat|int_neg_succ), Lit(Nat _))`. Returns
+  -- (found, sign, limbs). sign=0 for Int.ofNat, 1 for Int.negSucc.
+  fn try_extract_int(e: KExpr) -> (G, G, KLimbs) {
+    match load(e) {
+      KExprNode.App(f, a) =>
+        match load(f) {
+          KExprNode.Const(caddr, _) =>
+            let is_ofnat = address_eq(caddr, int_of_nat_addr_dec());
+            let is_negsucc = address_eq(caddr, int_neg_succ_addr_dec());
+            match is_ofnat + is_negsucc {
+              0 => (0, 0, store(ListNode.Nil)),
+              _ =>
+                match load(a) {
+                  KExprNode.Lit(lit) =>
+                    match lit {
+                      KLiteral.Nat(limbs) => (1, is_negsucc, limbs),
+                      _ => (0, 0, store(ListNode.Nil)),
+                    },
+                  _ => (0, 0, store(ListNode.Nil)),
+                },
+            },
+          _ => (0, 0, store(ListNode.Nil)),
+        },
+      _ => (0, 0, store(ListNode.Nil)),
     }
   }
 
-  -- Mirror: src/ix/kernel/infer.rs:418-427 Prop-projection guard. When
-  -- projecting a field from a Prop-typed structure, the field MUST itself
-  -- live in Prop. Otherwise projection violates proof irrelevance.
-  fn check_prop_field_if_prop(is_prop: G, dom: KExpr, types: List‹KExpr›,
-                               top: List‹&KConstantInfo›, addrs: List‹Addr›) {
-    match is_prop {
-      0 => (),
+  -- Build canonical `App(Const(int_of_nat | int_neg_succ), Lit(Nat n))`.
+  fn intern_int_lit(sign: G, kl: KLimbs) -> KExpr {
+    let head_addr = match sign {
+      0 => int_of_nat_addr_dec(),
+      _ => int_neg_succ_addr_dec(),
+    };
+    let head = store(KExprNode.Const(head_addr, store(ListNode.Nil)));
+    let lit = store(KExprNode.Lit(KLiteral.Nat(kl)));
+    store(KExprNode.App(head, lit))
+  }
+
+  -- Normalize Int.decLe/decLt/decEq spine args to canonical Int lit
+  -- form. If both already canonical, bail (0, _). Otherwise whnf both,
+  -- extract, rebuild `App(head, canonical_a, canonical_b, ...post)`.
+  -- Caller re-whnfs the rebuilt form; delta then unfolds Int.dec_* body
+  -- against canonical inputs.
+  fn try_normalize_int_decidable(head_addr: Addr,
+                                     head_lvls: List‹KLevel›,
+                                     spine: List‹KExpr›,
+                                     types: List‹KExpr›) -> (G, KExpr) {
+    match u32_less_than(list_length(spine), 2) {
+      1 => (0, store(KExprNode.BVar(0))),
       _ =>
-        let lvl = k_ensure_sort(dom, types, top, addrs);
-        assert_eq!(level_equal(lvl, store(KLevelNode.Zero)), 1);
-        (),
+        let a0 = list_lookup(spine, 0);
+        let a1 = list_lookup(spine, 1);
+        match try_extract_int(a0) {
+          (1, _, _) =>
+            match try_extract_int(a1) {
+              (1, _, _) => (0, store(KExprNode.BVar(0))),
+              _ => normalize_int_dec_rebuild(head_addr, head_lvls,
+                                              spine, a0, a1, types),
+            },
+          _ => normalize_int_dec_rebuild(head_addr, head_lvls,
+                                          spine, a0, a1, types),
+        },
     }
   }
 
-  -- Address-keyed literal-type lookup.
-  -- Walks `addrs` to find the kernel position of Nat / String. Builds
-  -- `Const(idx, [])` for the type of `Lit(Nat _)` / `Lit(Str _)`.
-  fn nat_const_type(addrs: List‹Addr›) -> KExpr {
-    let idx = find_addr_idx(nat_addr(), addrs, 0);
-    store(KExprNode.Const(idx, store(ListNode.Nil)))
+  fn normalize_int_dec_rebuild(head_addr: Addr, head_lvls: List‹KLevel›,
+                                spine: List‹KExpr›, a0: KExpr, a1: KExpr,
+                                types: List‹KExpr›) -> (G, KExpr) {
+    let wa = whnf(a0, types);
+    let wb = whnf(a1, types);
+    match try_extract_int(wa) {
+      (1, sa, na) =>
+        match try_extract_int(wb) {
+          (1, sb, nb) =>
+            let a_e = intern_int_lit(sa, na);
+            let b_e = intern_int_lit(sb, nb);
+            let head = store(KExprNode.Const(head_addr, head_lvls));
+            let r1 = store(KExprNode.App(head, a_e));
+            let r2 = store(KExprNode.App(r1, b_e));
+            let post = list_drop(spine, 2);
+            (1, apply_spine(r2, post)),
+          _ => (0, store(KExprNode.BVar(0))),
+        },
+      _ => (0, store(KExprNode.BVar(0))),
+    }
   }
 
-  fn str_const_type(addrs: List‹Addr›) -> KExpr {
-    let idx = find_addr_idx(str_addr(), addrs, 0);
-    store(KExprNode.Const(idx, store(ListNode.Nil)))
+  -- Entry point. Whnf calls this on Const-headed apps whose head addr
+  -- passes is_dec_prim_addr. Returns (1, reduced) on success or
+  -- (0, _) to fall through to Defn unfold.
+  fn try_dec_dispatch(head_addr: Addr, head_lvls: List‹KLevel›,
+                          spine: List‹KExpr›, types: List‹KExpr›)
+                          -> (G, KExpr) {
+    match u32_less_than(list_length(spine), 2) {
+      1 => (0, store(KExprNode.BVar(0))),
+      _ =>
+        match is_int_dec_prim_addr(head_addr) {
+          1 => try_normalize_int_decidable(head_addr, head_lvls,
+                                                spine, types),
+          _ =>
+            let is_le = address_eq(head_addr, nat_dec_le_addr_dec());
+            let is_eq = address_eq(head_addr, nat_dec_eq_addr_dec());
+            let is_lt = address_eq(head_addr, nat_dec_lt_addr_dec());
+            match is_lt {
+              1 => dec_rewrite_lt_to_le(head_lvls, spine, types),
+              _ => dec_dispatch_le_eq(is_le, is_eq, head_addr,
+                                       head_lvls, spine, types),
+            },
+        },
+    }
   }
 
-  -- Find the position of `target` in `addrs`. Panics (no Nil arm) if
-  -- not present — caller (literal typing) requires it.
-  fn find_addr_idx(target: Addr, addrs: List‹Addr›, i: G) -> G {
-    match load(addrs) {
-      ListNode.Cons(a, rest) =>
-        match address_eq(target, a) {
-          1 => i,
-          0 => find_addr_idx(target, rest, i + 1),
+  -- decLt n m → decLe (n+1) m: rewrite spine head + first arg, return
+  -- (1, App(dec_le, succ_n_lit, m_e, ...post)). Whnf caller re-whnfs
+  -- the rewritten form, which re-enters dispatch as the decLe arm.
+  fn dec_rewrite_lt_to_le(head_lvls: List‹KLevel›, spine: List‹KExpr›,
+                           types: List‹KExpr›) -> (G, KExpr) {
+    let n_e = list_lookup(spine, 0);
+    let m_e = list_lookup(spine, 1);
+    let n_w = whnf(n_e, types);
+    match try_extract_nat(n_w) {
+      (0, _) => (0, store(KExprNode.BVar(0))),
+      (1, n_klimbs) =>
+        let succ_lit = mk_nat_lit(klimbs_succ(n_klimbs));
+        let dec_le_head = store(KExprNode.Const(
+          nat_dec_le_addr_dec(), head_lvls));
+        let app1 = store(KExprNode.App(dec_le_head, succ_lit));
+        let app2 = store(KExprNode.App(app1, m_e));
+        let post = list_drop(spine, 2);
+        (1, apply_spine(app2, post)),
+    }
+  }
+
+  fn dec_dispatch_le_eq(is_le: G, is_eq: G,
+                         head_addr: Addr, head_lvls: List‹KLevel›,
+                         spine: List‹KExpr›, types: List‹KExpr›)
+                         -> (G, KExpr) {
+    let n_e = list_lookup(spine, 0);
+    let m_e = list_lookup(spine, 1);
+    let n_w = whnf(n_e, types);
+    let m_w = whnf(m_e, types);
+    match try_extract_nat(n_w) {
+      (0, _) => (0, store(KExprNode.BVar(0))),
+      (1, n_kl) =>
+        match try_extract_nat(m_w) {
+          (0, _) => (0, store(KExprNode.BVar(0))),
+          (1, m_kl) =>
+            let verdict = match is_le {
+              1 => klimbs_le(n_kl, m_kl),
+              _ => klimbs_eq(n_kl, m_kl),
+            };
+            dec_build_proof(is_le, is_eq, verdict, n_e, m_e,
+                            head_addr, head_lvls, spine, types),
         },
     }
   }
+
+  fn dec_build_proof(is_le: G, is_eq: G, verdict: G,
+                      n_e: KExpr, m_e: KExpr,
+                      head_addr: Addr, head_lvls: List‹KLevel›,
+                      spine: List‹KExpr›, types: List‹KExpr›)
+                      -> (G, KExpr) {
+    -- Bail decLe-false (needs Bool.noConfusion helper not exposed).
+    let bail = is_le * (1 - verdict);
+    match bail {
+      1 => (0, store(KExprNode.BVar(0))),
+      _ =>
+        -- Eq.refl.{1} Bool (Bool.true|Bool.false)
+        let one_lvl = store(KLevelNode.Succ(store(KLevelNode.Zero)));
+        let eq_refl_lvls = store(ListNode.Cons(one_lvl, store(ListNode.Nil)));
+        let eq_refl_c = store(KExprNode.Const(eq_refl_addr_dec(), eq_refl_lvls));
+        let bool_c = store(KExprNode.Const(bool_type_addr_dec(), store(ListNode.Nil)));
+        let bool_lit_addr = match verdict {
+          1 => bool_true_addr(),
+          _ => bool_false_addr(),
+        };
+        let bool_lit_c = store(KExprNode.Const(bool_lit_addr, store(ListNode.Nil)));
+        let r1 = store(KExprNode.App(eq_refl_c, bool_c));
+        let refl_proof = store(KExprNode.App(r1, bool_lit_c));
+        let proof_fn_addr = match is_le {
+          1 =>
+            match verdict {
+              1 => nat_le_of_ble_eq_true_addr_dec(),
+              _ => nat_not_le_of_not_ble_eq_true_addr_dec(),
+            },
+          _ =>
+            match verdict {
+              1 => nat_eq_of_beq_eq_true_addr_dec(),
+              _ => nat_ne_of_beq_eq_false_addr_dec(),
+            },
+        };
+        let proof_c = store(KExprNode.Const(proof_fn_addr, store(ListNode.Nil)));
+        let p1 = store(KExprNode.App(proof_c, n_e));
+        let p2 = store(KExprNode.App(p1, m_e));
+        let proof = store(KExprNode.App(p2, refl_proof));
+        dec_finish(verdict, proof, head_addr, head_lvls, spine, types),
+    }
+  }
+
+  -- String.decEq on two Lit(Str)-whnf'd args → Decidable.isTrue prop
+  -- (Eq.refl.{1} String lit) when bytestreams equal. Unequal bails
+  -- (no String.noConfusion helper). Entry point invoked from Whnf's
+  -- string primitive dispatch when head_addr matches string_dec_eq.
+  --
+  -- head_addr, spine assumed pre-whnf'd (caller runs whnf_spine).
+  fn try_str_dec_eq(head_addr: Addr, spine: List‹KExpr›,
+                        types: List‹KExpr›) -> (G, KExpr) {
+    match u32_less_than(list_length(spine), 2) {
+      1 => (0, store(KExprNode.BVar(0))),
+      _ =>
+        let a0 = list_lookup(spine, 0);
+        let a1 = list_lookup(spine, 1);
+        match load(a0) {
+          KExprNode.Lit(la) =>
+            match la {
+              KLiteral.Str(sa) =>
+                match load(a1) {
+                  KExprNode.Lit(lb) =>
+                    match lb {
+                      KLiteral.Str(sb) =>
+                        match bytestream_eq(sa, sb) {
+                          0 => (0, store(KExprNode.BVar(0))),
+                          _ => str_dec_eq_build(sa, head_addr, spine, types),
+                        },
+                      _ => (0, store(KExprNode.BVar(0))),
+                    },
+                  _ => (0, store(KExprNode.BVar(0))),
+                },
+              _ => (0, store(KExprNode.BVar(0))),
+            },
+          _ => (0, store(KExprNode.BVar(0))),
+        },
+    }
+  }
+
+  fn str_dec_eq_build(sa: ByteStream, head_addr: Addr, spine: List‹KExpr›,
+                       types: List‹KExpr›) -> (G, KExpr) {
+    let one_lvl = store(KLevelNode.Succ(store(KLevelNode.Zero)));
+    let eq_refl_lvls = store(ListNode.Cons(one_lvl, store(ListNode.Nil)));
+    let eq_refl_c = store(KExprNode.Const(eq_refl_addr_dec(), eq_refl_lvls));
+    let str_c = store(KExprNode.Const(string_type_addr(),
+                                        store(ListNode.Nil)));
+    let lit = store(KExprNode.Lit(KLiteral.Str(sa)));
+    let r1 = store(KExprNode.App(eq_refl_c, str_c));
+    let refl = store(KExprNode.App(r1, lit));
+    -- Recover prop from Decidable prop = infer(head, a0, a1).
+    let head_c = store(KExprNode.Const(head_addr, store(ListNode.Nil)));
+    let two_args = list_take(spine, 2);
+    let call_expr = apply_spine(head_c, two_args);
+    let call_ty = k_infer(call_expr, types);
+    let call_ty_w = whnf(call_ty, types);
+    match collect_spine(call_ty_w) {
+      (_, dec_args) =>
+        match u32_less_than(list_length(dec_args), 1) {
+          1 => (0, store(KExprNode.BVar(0))),
+          _ =>
+            let prop = list_lookup(dec_args, 0);
+            let dec_c = store(KExprNode.Const(decidable_is_true_addr_dec(),
+                                                store(ListNode.Nil)));
+            let d1 = store(KExprNode.App(dec_c, prop));
+            let d2 = store(KExprNode.App(d1, refl));
+            let post = list_drop(spine, 2);
+            (1, apply_spine(d2, post)),
+        },
+    }
+  }
+
+  -- Recover `prop` from `Decidable prop` type of the (head, n, m) call.
+  -- Build `Decidable.isTrue prop proof` / `Decidable.isFalse prop proof`.
+  fn dec_finish(verdict: G, proof: KExpr, head_addr: Addr,
+                 head_lvls: List‹KLevel›, spine: List‹KExpr›,
+                 types: List‹KExpr›) -> (G, KExpr) {
+    let dec_addr = match verdict {
+      1 => decidable_is_true_addr_dec(),
+      _ => decidable_is_false_addr_dec(),
+    };
+    let head_c = store(KExprNode.Const(head_addr, head_lvls));
+    let two_args = list_take(spine, 2);
+    let call_expr = apply_spine(head_c, two_args);
+    let call_ty = k_infer(call_expr, types);
+    let call_ty_w = whnf(call_ty, types);
+    match collect_spine(call_ty_w) {
+      (_, dec_args) =>
+        match u32_less_than(list_length(dec_args), 1) {
+          1 => (0, store(KExprNode.BVar(0))),
+          _ =>
+            let prop = list_lookup(dec_args, 0);
+            let dec_c = store(KExprNode.Const(dec_addr, store(ListNode.Nil)));
+            let d1 = store(KExprNode.App(dec_c, prop));
+            let d2 = store(KExprNode.App(d1, proof));
+            let post = list_drop(spine, 2);
+            (1, apply_spine(d2, post)),
+        },
+    }
+  }
+
 ⟧
 
 end IxVM
diff --git a/Ix/IxVM/Kernel/InferOnly.lean b/Ix/IxVM/Kernel/InferOnly.lean
new file mode 100644
index 000000000..c67059d8b
--- /dev/null
+++ b/Ix/IxVM/Kernel/InferOnly.lean
@@ -0,0 +1,243 @@
+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
+
+namespace IxVM
+
+/-! ## Infer-Only
+
+Mirror `with_infer_only` (crates/kernel/src/infer.rs).
+
+Type synthesis ONLY. Skips inner validations: App drops
+`k_check(a, dom)`, Lam drops `k_ensure_sort(ty)`, Let drops val/ty
+checks, Proj drops prop-field checks.
+
+Called by `try_proof_irrel` inside `k_is_def_eq` — placing it in
+its own module breaks the DefEq ↔ Infer cycle.
+
+Safety: MUST NOT be called on ill-typed terms. Callers hand in
+subterms already known well-typed (e.g. one whnf'd side of a running
+def-eq comparison).
+-/
+
+def inferOnly := ⟦
+  fn io_types_lookup(types: List‹KExpr›, i: G) -> KExpr {
+    let ty = list_lookup(types, i);
+    expr_lift(ty, i + 1, 0)
+  }
+
+  fn io_const_num_lvls(ci: KConstantInfo) -> G {
+    match ci {
+      KConstantInfo.Axiom(n, _, _) => n,
+      KConstantInfo.Defn(n, _, _, _, _) => n,
+      KConstantInfo.Thm(n, _, _) => n,
+      KConstantInfo.Opaque(n, _, _, _) => n,
+      KConstantInfo.Quot(n, _, _) => n,
+      KConstantInfo.Induct(n, _, _, _, _, _, _, _) => n,
+      KConstantInfo.Ctor(n, _, _, _, _, _, _, _) => n,
+      KConstantInfo.Rec(n, _, _, _, _, _, _, _, _, _, _) => n,
+    }
+  }
+
+  fn io_const_type_of(ci: KConstantInfo) -> KExpr {
+    match ci {
+      KConstantInfo.Axiom(_, ty, _) => ty,
+      KConstantInfo.Defn(_, ty, _, _, _) => ty,
+      KConstantInfo.Thm(_, ty, _) => ty,
+      KConstantInfo.Opaque(_, ty, _, _) => ty,
+      KConstantInfo.Quot(_, ty, _) => ty,
+      KConstantInfo.Induct(_, ty, _, _, _, _, _, _) => ty,
+      KConstantInfo.Ctor(_, ty, _, _, _, _, _, _) => ty,
+      KConstantInfo.Rec(_, ty, _, _, _, _, _, _, _, _, _) => ty,
+    }
+  }
+
+  fn nat_addr_io() -> Addr {
+    store([0x39u8, 0x8au8, 0x77u8, 0x06u8, 0xcfu8, 0x13u8, 0xf2u8, 0x23u8,
+     0x99u8, 0x2du8, 0x17u8, 0x3du8, 0xceu8, 0x07u8, 0x94u8, 0x68u8,
+     0x57u8, 0x24u8, 0x0fu8, 0x49u8, 0xafu8, 0xccu8, 0x74u8, 0x37u8,
+     0x23u8, 0xe8u8, 0x39u8, 0xf8u8, 0xf3u8, 0xf2u8, 0xb6u8, 0x31u8])
+  }
+
+  fn str_addr_io() -> Addr {
+    store([0x7au8, 0xb2u8, 0xd5u8, 0x2au8, 0xc5u8, 0x2fu8, 0xd1u8, 0xf5u8,
+     0x18u8, 0x09u8, 0xb7u8, 0x18u8, 0xe5u8, 0x3cu8, 0xd0u8, 0x58u8,
+     0xacu8, 0x4bu8, 0x50u8, 0xd6u8, 0x51u8, 0x50u8, 0xe7u8, 0x8au8,
+     0xe6u8, 0x19u8, 0x13u8, 0x9cu8, 0xcfu8, 0x13u8, 0xc8u8, 0xfdu8])
+  }
+
+  -- k_infer_only: type-synthesis-only (mirror Rust `with_infer_only`).
+  -- Skips inner validations: App drops `k_check(a, dom)`; Lam drops
+  -- `k_ensure_sort(ty)`; Let drops val/ty checks. Distinct Aiur memo from
+  -- `k_infer` (parity with Rust's separate infer_cache / infer_only_cache).
+  -- Used at try_proof_irrel / is_prop_type / try_unit_like where only the
+  -- synthesized type is needed.
+  -- ## Safety invariant
+  -- `k_infer_only` is NOT safe to call on an arbitrary term — only on terms
+  -- already known to be well-typed (i.e., terms that would have passed
+  -- `k_infer`). The reason: our overall invariant is that evaluation only
+  -- happens after typechecking. `k_infer_only` evaluates types (e.g. the
+  -- substitution `B[a/x]` on an `App` arm) WITHOUT first checking that the
+  -- substituted-in argument `a` has the proper type (the dropped
+  -- `k_check(a, dom)`). On an untyped or ill-typed term, that substitution
+  -- can take us out of the well-typed fragment, after which subsequent
+  -- `whnf` / `def_eq` work is unsound.
+  -- The current call sites (`try_proof_irrel`, `is_prop_type`,
+  -- `try_unit_like`) honor this invariant because they hand `k_infer_only`
+  -- a term obtained by `whnf`-ing a well-typed input. `whnf` of a
+  -- well-typed term yields a structurally different but still well-typed
+  -- term, so the no-checks shortcut is sound there even though the result
+  -- term itself was never the direct subject of `k_infer`.
+  -- ## Future: shared memo via non-deterministic hint
+  -- `k_infer_only`'s separate memo (parity with Rust) means an `infer_only`
+  -- call cannot reuse an existing `k_infer` hit on the same input. A
+  -- planned improvement: at each `try_proof_irrel` / `try_unit_like` site,
+  -- the prover supplies a hint `enum Hint { None, KInfer, KInferOnly }`:
+  -- 1. `None`         — term is not unit-like and not a proof; skip both
+  -- and fall through to deep `def_eq`.
+  -- 2. `KInfer`       — `k_infer`'s memo is a hit on this input; call
+  -- `k_infer` (cheap, reuses the cached row) and
+  -- check the result is a proof / unit-like.
+  -- 3. `KInferOnly`   — `k_infer`'s memo would miss; call `k_infer_only`
+  -- (cheaper than a fresh `k_infer`) and check.
+  -- Dispatching on the hint with a `match` lets us share `k_infer`'s memo
+  -- where available and fall back to `k_infer_only` only when the cheaper
+  -- path won't pay off, instead of unconditionally paying the parallel
+  -- `infer_only` memo cost.
+  fn k_infer_only(e: KExpr, types: List‹KExpr›) -> KExpr {
+    k_infer_only_core(e, ctx_trim(types, expr_lbr(e)))
+  }
+
+  fn k_infer_only_core(e: KExpr, types: List‹KExpr›) -> KExpr {
+    match load(e) {
+      KExprNode.BVar(i) => io_types_lookup(types, i),
+
+      KExprNode.Srt(l) =>
+        store(KExprNode.Srt(level_reduce(store(KLevelNode.Succ(l))))),
+
+      KExprNode.Const(addr, lvls) =>
+        let ci = load(get_ci(addr));
+        let expected = io_const_num_lvls(ci);
+        assert_eq!(list_length(lvls), expected,
+          "Const applied to wrong number of universe levels");
+        let ty = io_const_type_of(ci);
+        expr_inst_levels(ty, lvls),
+
+      KExprNode.App(f, a) =>
+        let f_ty = k_infer_only(f, types);
+        match load(f_ty) {
+          KExprNode.Forall(_, cod) => expr_inst1(cod, a, 0),
+          _ =>
+            let f_ty_whnf = whnf(f_ty, types);
+            match load(f_ty_whnf) {
+              KExprNode.Forall(_, cod) => expr_inst1(cod, a, 0),
+            },
+        },
+
+      KExprNode.Lam(ty, body) =>
+        let types2 = store(ListNode.Cons(ty, types));
+        let body_ty = k_infer_only(body, types2);
+        store(KExprNode.Forall(ty, body_ty)),
+
+      KExprNode.Forall(ty, body) =>
+        let u1 = ensure_sort_only(ty, types);
+        let types2 = store(ListNode.Cons(ty, types));
+        let u2 = ensure_sort_only(body, types2);
+        store(KExprNode.Srt(level_imax(u1, u2))),
+
+      KExprNode.Let(_, val, body) =>
+        let body_substed = expr_inst1(body, val, 0);
+        k_infer_only(body_substed, types),
+
+      KExprNode.Lit(lit) =>
+        match lit {
+          KLiteral.Nat(_) =>
+            store(KExprNode.Const(nat_addr_io(), store(ListNode.Nil))),
+          KLiteral.Str(_) =>
+            store(KExprNode.Const(str_addr_io(), store(ListNode.Nil))),
+        },
+
+      -- Proj arm: minimal, mirrors k_infer_proj without prop checks.
+      KExprNode.Proj(struct_addr, fidx, e1) =>
+        let val_ty = k_infer_only(e1, types);
+        let wty = whnf(val_ty, types);
+        match collect_spine(wty) {
+          (head, args) =>
+            match load(head) {
+              KExprNode.Const(head_addr, lvls) =>
+                assert_eq!(ptr_val(head_addr), ptr_val(struct_addr),
+                  "projection's structure type differs from the value's head");
+                let ind_ci = load(get_ci(head_addr));
+                match ind_ci {
+                  KConstantInfo.Induct(_, _, n_params, _, num_ctors, _,
+                                         block_addr, ind_idx) =>
+                    -- Structure requirement, as in `k_infer_proj`. Enforced here
+                    -- too: this path skips the inner checks, not the ones that
+                    -- decide which constructor's fields are being read.
+                    assert_eq!(num_ctors, 1,
+                      "projection on an inductive with more than one constructor");
+                    let ctor_ci = load(get_ci_cprj(block_addr, ind_idx, 0));
+                    match ctor_ci {
+                      KConstantInfo.Ctor(_, ctor_ty, _, _, _, _, _, _) =>
+                        let ctor_ty_inst = expr_inst_levels(ctor_ty, lvls);
+                        let after_params = io_peel_params_subst(ctor_ty_inst, args, n_params);
+                        io_peel_field_loop(after_params, fidx, 0, struct_addr, e1),
+                    },
+                },
+            },
+        },
+    }
+  }
+
+  fn ensure_sort_only(e: KExpr, types: List‹KExpr›) -> KLevel {
+    let ty = k_infer_only(e, types);
+    match load(ty) {
+      KExprNode.Srt(l) => l,
+      _ =>
+        let ty_whnf = whnf(ty, types);
+        match load(ty_whnf) {
+          KExprNode.Srt(l) => l,
+        },
+    }
+  }
+
+  fn io_peel_params_subst(ty: KExpr, args: List‹KExpr›, n_params: G) -> KExpr {
+    match n_params {
+      0 => ty,
+      _ =>
+        match load(ty) {
+          KExprNode.Forall(_, body) =>
+            match load(args) {
+              ListNode.Cons(arg, rest) =>
+                let body_substed = expr_inst1(body, arg, 0);
+                io_peel_params_subst(body_substed, rest, n_params - 1),
+            },
+        },
+    }
+  }
+
+  fn io_peel_field_loop(ty: KExpr, target: G, current: G,
+                            struct_addr: Addr, val: KExpr) -> KExpr {
+    match load(ty) {
+      KExprNode.Forall(dom, body) =>
+        match target - current {
+          0 => dom,
+          _ =>
+            let proj_expr = store(KExprNode.Proj(struct_addr, current, val));
+            let body_substed = expr_inst1(body, proj_expr, 0);
+            io_peel_field_loop(body_substed, target, current + 1,
+                                    struct_addr, val),
+        },
+    }
+  }
+⟧
+
+end IxVM
+
+end
diff --git a/Ix/IxVM/Kernel/Klimbs.lean b/Ix/IxVM/Kernel/Klimbs.lean
new file mode 100644
index 000000000..272070395
--- /dev/null
+++ b/Ix/IxVM/Kernel/Klimbs.lean
@@ -0,0 +1,668 @@
+module
+public import Ix.Aiur.Meta
+
+set_option maxRecDepth 8192
+
+public section
+
+namespace IxVM
+
+/-! ## KLimbs bignum arithmetic
+
+Bignum gadgets backing the Nat primitives (see crates/kernel/src/primitive.rs).
+
+Kept in a module of its own, separate from the primitive dispatch that
+consumes it, so the arithmetic can be read and tested without the
+address-recognition machinery around it.
+
+Ops covered:
+- klimbs_succ / klimbs_dec / klimbs_add / klimbs_sub / klimbs_le /
+  klimbs_is_zero / klimbs_normalize
+- klimbs_mul (schoolbook) / klimbs_div / klimbs_mod / klimbs_div_mod
+  (unconstrained big-uint witness)
+- klimbs_gcd (Euclidean) / klimbs_pow (binary exponentiation)
+- klimbs_land / klimbs_lor / klimbs_xor_op
+- klimbs_shl / klimbs_shr (via mul/div by 2^n)
+- u64_add / u64_mul (byte schoolbook) / u64_sub_with_borrow /
+  u64_and / u64_or / u64_xor_kbits (element-wise byte ops)
+- divmod_256 / split_carry (unconstrained witness generators for
+  u64_mul column decomposition)
+
+Aiur builtin gadgets used (compiler-provided): u8_add, u8_sub,
+u8_xor, u8_and, u8_or, u8_from_field_unsafe, u32_less_than,
+u64_add, u64_is_zero, list_snoc, unconstrained_big_uint_div_mod,
+#split_carry.
+-/
+
+set_option maxRecDepth 16384 in
+def klimbs := ⟦
+
+  -- Mirror: BigUint::succ. Increment a KLimbs by 1; ripple carry.
+  fn klimbs_succ(n: KLimbs) -> KLimbs {
+    match load(n) {
+      ListNode.Nil =>
+        store(ListNode.Cons([1u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], store(ListNode.Nil))),
+      ListNode.Cons(limb, rest) =>
+        let pair = u64_add(limb, [1u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]);
+        match pair {
+          (sum, carry) =>
+            match carry {
+              0 => store(ListNode.Cons(sum, rest)),
+              _ => store(ListNode.Cons(sum, klimbs_succ(rest))),
+            },
+        },
+    }
+  }
+
+  -- Mirror: BigUint::add. Limb-wise add with ripple carry.
+  -- KLimbs are little-endian; head = least significant.
+  -- Asymmetric lengths handled by terminating on shorter list and
+  -- propagating carry into the longer.
+  fn klimbs_add_carry(a: KLimbs, b: KLimbs, carry: G) -> KLimbs {
+    match load(a) {
+      ListNode.Nil =>
+        match carry {
+          0 => b,
+          _ => klimbs_succ(b),
+        },
+      ListNode.Cons(la, ra) =>
+        match load(b) {
+          ListNode.Nil =>
+            match carry {
+              0 => a,
+              _ => klimbs_succ(a),
+            },
+          ListNode.Cons(lb, rb) =>
+            let pair1 = u64_add(la, lb);
+            match pair1 {
+              (sum1, carry1) =>
+                let pair2 = u64_add(sum1, [u8_from_field_unsafe(carry), 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]);
+                match pair2 {
+                  (sum2, carry2) =>
+                    -- carry1, carry2 mutually exclusive: carry1=1 ⇒ sum1 ≤
+                    -- 2^64-2 ⇒ sum1 + carry_in ≤ 2^64-1 ⇒ carry2=0.
+                    let total_carry = to_field(carry1) + to_field(carry2);
+                    store(ListNode.Cons(sum2, klimbs_add_carry(ra, rb, total_carry))),
+                },
+            },
+        },
+    }
+  }
+
+  fn klimbs_add(a: KLimbs, b: KLimbs) -> KLimbs {
+    klimbs_add_carry(a, b, 0)
+  }
+
+  -- Mirror: byte-wise u64_sub with explicit final borrow.
+  -- Per-byte: u_t = borrow(a_i - b_i); u_r = borrow((a_i + 256 - b_i) - br_in).
+  -- u_t = 1 ⇒ a_i + 256 - b_i ≥ 1 ⇒ subtracting br_in ∈ {0,1} cannot underflow
+  -- ⇒ u_r = 0. So `u_t` and `u_r` are mutually-exclusive 0/1 values; field `+`
+  -- substitutes for `g_or` (which charges +1 aux +1 lookup per call). See
+  -- [[reference_aiur_carry_add]].
+  fn u64_sub_with_borrow(a: U64, b: U64) -> (U64, G) {
+    let [a0, a1, a2, a3, a4, a5, a6, a7] = a;
+    let [b0, b1, b2, b3, b4, b5, b6, b7] = b;
+    let (r0, br1) = u8_sub(a0, b0);
+    let (t1, u_t1) = u8_sub(a1, b1);
+    let (r1, u_r1) = u8_sub(t1, br1);
+    let br2 = to_field(u_t1) + to_field(u_r1);
+    let (t2, u_t2) = u8_sub(a2, b2);
+    let (r2, u_r2) = u8_sub(t2, u8_from_field_unsafe(br2));
+    let br3 = to_field(u_t2) + to_field(u_r2);
+    let (t3, u_t3) = u8_sub(a3, b3);
+    let (r3, u_r3) = u8_sub(t3, u8_from_field_unsafe(br3));
+    let br4 = to_field(u_t3) + to_field(u_r3);
+    let (t4, u_t4) = u8_sub(a4, b4);
+    let (r4, u_r4) = u8_sub(t4, u8_from_field_unsafe(br4));
+    let br5 = to_field(u_t4) + to_field(u_r4);
+    let (t5, u_t5) = u8_sub(a5, b5);
+    let (r5, u_r5) = u8_sub(t5, u8_from_field_unsafe(br5));
+    let br6 = to_field(u_t5) + to_field(u_r5);
+    let (t6, u_t6) = u8_sub(a6, b6);
+    let (r6, u_r6) = u8_sub(t6, u8_from_field_unsafe(br6));
+    let br7 = to_field(u_t6) + to_field(u_r6);
+    let (t7, u_t7) = u8_sub(a7, b7);
+    let (r7, u_r7) = u8_sub(t7, u8_from_field_unsafe(br7));
+    let final_borrow = to_field(u_t7) + to_field(u_r7);
+    ([r0, r1, r2, r3, r4, r5, r6, r7], final_borrow)
+  }
+
+  -- Mirror: BigUint::sub with saturating-at-zero (Lean Nat.sub semantics).
+  -- a - b clamped to 0 when b > a.
+  --
+  -- Walk both lists in parallel limb-by-limb with borrow ripple. If the
+  -- final borrow is 1 OR `b` has more limbs than `a`, return 0 (Nil).
+  -- Otherwise normalize trailing zero limbs.
+  fn klimbs_sub_borrow(a: KLimbs, b: KLimbs, borrow: G) -> (KLimbs, G) {
+    match load(a) {
+      ListNode.Nil =>
+        match load(b) {
+          ListNode.Nil =>
+            -- 0 - 0 - borrow: borrow=1 → underflow.
+            (store(ListNode.Nil), borrow),
+          ListNode.Cons(_, _) =>
+            -- 0 - non-empty. A non-empty limb list is not necessarily a
+            -- non-zero number: trailing zero limbs are a valid encoding, and
+            -- `klimbs_div`/`klimbs_mod` hand back the raw prover-supplied
+            -- q/r, so denormalized operands do reach here. Treating every
+            -- non-empty `b` as an underflow made `klimbs_le([3], [2,0])`
+            -- certify "3 <= 2".
+            match klimbs_is_zero(b) {
+              1 => (store(ListNode.Nil), borrow),
+              _ => (store(ListNode.Nil), 1),
+            },
+        },
+      ListNode.Cons(la, ra) =>
+        match load(b) {
+          ListNode.Nil =>
+            -- a - 0 - borrow: subtract borrow from la, propagate.
+            match borrow {
+              0 => (a, 0),
+              _ =>
+                let pair = u64_sub_with_borrow(la, [1u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]);
+                match pair {
+                  (diff, br) =>
+                    let pair2 = klimbs_sub_borrow(ra, store(ListNode.Nil), br);
+                    match pair2 {
+                      (rest_res, br2) =>
+                        (store(ListNode.Cons(diff, rest_res)), br2),
+                    },
+                },
+            },
+          ListNode.Cons(lb, rb) =>
+            let pair1 = u64_sub_with_borrow(la, lb);
+            match pair1 {
+              (sum1, br1) =>
+                let pair2 = u64_sub_with_borrow(sum1, [u8_from_field_unsafe(borrow), 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]);
+                match pair2 {
+                  (sum2, br2) =>
+                    -- br1, br2 mutually exclusive: br1=1 ⇒ sum1 ≥ 1 ⇒
+                    -- sum1 - borrow ≥ 0 ⇒ br2=0.
+                    let total = br1 + br2;
+                    let rec_pair = klimbs_sub_borrow(ra, rb, total);
+                    match rec_pair {
+                      (rest_res, br_final) =>
+                        (store(ListNode.Cons(sum2, rest_res)), br_final),
+                    },
+                },
+            },
+        },
+    }
+  }
+
+  -- Strip trailing zero limbs (canonicalize `[k, 0, 0]` → `[k]`).
+  -- Force every limb byte of a prover-supplied `KLimbs` into [0, 256).
+  --
+  -- `KLimbs` is canonical in two independent ways — no trailing zero
+  -- limbs, and every byte in range — and `klimbs_normalize` only
+  -- establishes the first. The second matters because `klimbs_eq` is a
+  -- raw limb compare: a value-correct but digit-wrong `KLimbs` compares
+  -- unequal to its canonical form, so `Nat.beq` answers `false` where
+  -- Lean answers `true`. `u8_range_check` takes a pair per lookup row,
+  -- so eight bytes cost four.
+  fn klimbs_range_check(n: KLimbs) {
+    match load(n) {
+      ListNode.Nil => (),
+      ListNode.Cons(limb, rest) =>
+        let [b0, b1, b2, b3, b4, b5, b6, b7] = limb;
+        let (_, _) = u8_range_check(to_field(b0), to_field(b1));
+        let (_, _) = u8_range_check(to_field(b2), to_field(b3));
+        let (_, _) = u8_range_check(to_field(b4), to_field(b5));
+        let (_, _) = u8_range_check(to_field(b6), to_field(b7));
+        klimbs_range_check(rest),
+    }
+  }
+
+  fn klimbs_normalize(n: KLimbs) -> KLimbs {
+    match load(n) {
+      ListNode.Nil => store(ListNode.Nil),
+      ListNode.Cons(limb, rest) =>
+        let normalized_rest = klimbs_normalize(rest);
+        match load(normalized_rest) {
+          ListNode.Nil =>
+            match u64_is_zero(limb) {
+              1 => store(ListNode.Nil),
+              0 => store(ListNode.Cons(limb, store(ListNode.Nil))),
+            },
+          _ => store(ListNode.Cons(limb, normalized_rest)),
+        },
+    }
+  }
+
+  fn klimbs_sub(a: KLimbs, b: KLimbs) -> KLimbs {
+    let pair = klimbs_sub_borrow(a, b, 0);
+    match pair {
+      (result, borrow) =>
+        match borrow {
+          1 => store(ListNode.Nil),
+          0 => klimbs_normalize(result),
+        },
+    }
+  }
+
+  -- Mirror: Nat.le. Returns 1 if a ≤ b, 0 otherwise.
+  -- Uses saturating sub: a ≤ b iff (a - b) saturates to 0.
+  fn klimbs_le(a: KLimbs, b: KLimbs) -> G {
+    let diff = klimbs_sub(a, b);
+    match load(diff) {
+      ListNode.Nil => 1,
+      _ => 0,
+    }
+  }
+
+  -- Mirror: Nat.pred. Saturating decrement; pred(0) = 0.
+  fn klimbs_dec(a: KLimbs) -> KLimbs {
+    let one = store(ListNode.Cons([1u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], store(ListNode.Nil)));
+    klimbs_sub(a, one)
+  }
+
+  -- Returns (remainder, quotient): remainder = x mod 256, quotient = x / 256.
+  -- Repeated subtraction. Only ever invoked from the `#split_carry` /
+  -- `#split_u32` unconstrained witness generators, so the O(x/256)
+  -- iteration cost is off-circuit (untraced).
+  fn divmod_256(x: G, q: G) -> (G, G) {
+    match u32_less_than(x, 256) {
+      1 => (x, q),
+      0 => divmod_256(x - 256, q + 1),
+    }
+  }
+
+  -- Unconstrained witness generator: split `x` into its low byte `limb`
+  -- and the two bytes (clo, chi) of `x div 256`. Always invoked as
+  -- `#split_carry(...)`; the result is prover-provided and MUST be pinned
+  -- by the caller with u8 range checks + a reconstruction assert. The
+  -- division here is off-circuit (untraced), so its cost is irrelevant.
+  fn split_carry(x: G) -> (G, G, G) {
+    match divmod_256(x, 0) {
+      (limb, quot) =>
+        match divmod_256(quot, 0) {
+          (clo, chi) => (limb, clo, chi),
+        },
+    }
+  }
+
+  -- u64×u64 → (lo: U64, hi: U64) via byte schoolbook. Faithful port of the
+  -- `MulWitness`/`Product` reference: column k is the raw field sum
+  -- Σ_{i+j=k} a[i]*b[j]; each column accumulator `out` is decomposed by a
+  -- prover-provided (unconstrained) split into result byte + 16-bit carry,
+  -- then pinned by three u8 range checks (`u8_xor(_, 0)`) and the
+  -- reconstruction assert `out == limb + 256·clo + 65536·chi`. No `u8_mul`
+  -- gadget and no constrained division. Column accumulators are < 2^19, so
+  -- the decomposition into (limb, clo, chi) ∈ [0,256)³ is unique → sound.
+  fn u64_mul(a: U64, b: U64) -> (U64, U64) {
+    let [a0, a1, a2, a3, a4, a5, a6, a7] = a;
+    let [b0, b1, b2, b3, b4, b5, b6, b7] = b;
+    let col0 = (to_field(a0) * to_field(b0));
+    let col1 = (to_field(a0) * to_field(b1)) + (to_field(a1) * to_field(b0));
+    let col2 = (to_field(a0) * to_field(b2)) + (to_field(a1) * to_field(b1)) + (to_field(a2) * to_field(b0));
+    let col3 = (to_field(a0) * to_field(b3)) + (to_field(a1) * to_field(b2)) + (to_field(a2) * to_field(b1)) + (to_field(a3) * to_field(b0));
+    let col4 = (to_field(a0) * to_field(b4)) + (to_field(a1) * to_field(b3)) + (to_field(a2) * to_field(b2)) + (to_field(a3) * to_field(b1)) + (to_field(a4) * to_field(b0));
+    let col5 = (to_field(a0) * to_field(b5)) + (to_field(a1) * to_field(b4)) + (to_field(a2) * to_field(b3)) + (to_field(a3) * to_field(b2)) + (to_field(a4) * to_field(b1)) + (to_field(a5) * to_field(b0));
+    let col6 = (to_field(a0) * to_field(b6)) + (to_field(a1) * to_field(b5)) + (to_field(a2) * to_field(b4)) + (to_field(a3) * to_field(b3)) + (to_field(a4) * to_field(b2)) + (to_field(a5) * to_field(b1)) + (to_field(a6) * to_field(b0));
+    let col7 = (to_field(a0) * to_field(b7)) + (to_field(a1) * to_field(b6)) + (to_field(a2) * to_field(b5)) + (to_field(a3) * to_field(b4)) + (to_field(a4) * to_field(b3)) + (to_field(a5) * to_field(b2)) + (to_field(a6) * to_field(b1)) + (to_field(a7) * to_field(b0));
+    let col8 = (to_field(a1) * to_field(b7)) + (to_field(a2) * to_field(b6)) + (to_field(a3) * to_field(b5)) + (to_field(a4) * to_field(b4)) + (to_field(a5) * to_field(b3)) + (to_field(a6) * to_field(b2)) + (to_field(a7) * to_field(b1));
+    let col9 = (to_field(a2) * to_field(b7)) + (to_field(a3) * to_field(b6)) + (to_field(a4) * to_field(b5)) + (to_field(a5) * to_field(b4)) + (to_field(a6) * to_field(b3)) + (to_field(a7) * to_field(b2));
+    let col10 = (to_field(a3) * to_field(b7)) + (to_field(a4) * to_field(b6)) + (to_field(a5) * to_field(b5)) + (to_field(a6) * to_field(b4)) + (to_field(a7) * to_field(b3));
+    let col11 = (to_field(a4) * to_field(b7)) + (to_field(a5) * to_field(b6)) + (to_field(a6) * to_field(b5)) + (to_field(a7) * to_field(b4));
+    let col12 = (to_field(a5) * to_field(b7)) + (to_field(a6) * to_field(b6)) + (to_field(a7) * to_field(b5));
+    let col13 = (to_field(a6) * to_field(b7)) + (to_field(a7) * to_field(b6));
+    let col14 = (to_field(a7) * to_field(b7));
+    match #split_carry(col0) {
+      (rl0, rc0, rh0) =>
+        let r0 = u8_xor(u8_from_field_unsafe(rl0), 0u8);
+        let lo0 = u8_xor(u8_from_field_unsafe(rc0), 0u8);
+        let hi0 = u8_xor(u8_from_field_unsafe(rh0), 0u8);
+        assert_eq!(col0, to_field(r0) + (256 * to_field(lo0)) + (65536 * to_field(hi0)),
+          "u64_mul column 0: split_carry hint does not recompose to the column sum");
+        let out1 = col1 + to_field(lo0) + (256 * to_field(hi0));
+        match #split_carry(out1) {
+          (rl1, rc1, rh1) =>
+            let r1 = u8_xor(u8_from_field_unsafe(rl1), 0u8);
+            let lo1 = u8_xor(u8_from_field_unsafe(rc1), 0u8);
+            let hi1 = u8_xor(u8_from_field_unsafe(rh1), 0u8);
+            assert_eq!(out1, to_field(r1) + (256 * to_field(lo1)) + (65536 * to_field(hi1)),
+              "u64_mul column 1: split_carry hint does not recompose to the column sum");
+            let out2 = col2 + to_field(lo1) + (256 * to_field(hi1));
+            match #split_carry(out2) {
+              (rl2, rc2, rh2) =>
+                let r2 = u8_xor(u8_from_field_unsafe(rl2), 0u8);
+                let lo2 = u8_xor(u8_from_field_unsafe(rc2), 0u8);
+                let hi2 = u8_xor(u8_from_field_unsafe(rh2), 0u8);
+                assert_eq!(out2, to_field(r2) + (256 * to_field(lo2)) + (65536 * to_field(hi2)),
+                  "u64_mul column 2: split_carry hint does not recompose to the column sum");
+                let out3 = col3 + to_field(lo2) + (256 * to_field(hi2));
+                match #split_carry(out3) {
+                  (rl3, rc3, rh3) =>
+                    let r3 = u8_xor(u8_from_field_unsafe(rl3), 0u8);
+                    let lo3 = u8_xor(u8_from_field_unsafe(rc3), 0u8);
+                    let hi3 = u8_xor(u8_from_field_unsafe(rh3), 0u8);
+                    assert_eq!(out3, to_field(r3) + (256 * to_field(lo3)) + (65536 * to_field(hi3)),
+                      "u64_mul column 3: split_carry hint does not recompose to the column sum");
+                    let out4 = col4 + to_field(lo3) + (256 * to_field(hi3));
+                    match #split_carry(out4) {
+                      (rl4, rc4, rh4) =>
+                        let r4 = u8_xor(u8_from_field_unsafe(rl4), 0u8);
+                        let lo4 = u8_xor(u8_from_field_unsafe(rc4), 0u8);
+                        let hi4 = u8_xor(u8_from_field_unsafe(rh4), 0u8);
+                        assert_eq!(out4, to_field(r4) + (256 * to_field(lo4)) + (65536 * to_field(hi4)),
+                          "u64_mul column 4: split_carry hint does not recompose to the column sum");
+                        let out5 = col5 + to_field(lo4) + (256 * to_field(hi4));
+                        match #split_carry(out5) {
+                          (rl5, rc5, rh5) =>
+                            let r5 = u8_xor(u8_from_field_unsafe(rl5), 0u8);
+                            let lo5 = u8_xor(u8_from_field_unsafe(rc5), 0u8);
+                            let hi5 = u8_xor(u8_from_field_unsafe(rh5), 0u8);
+                            assert_eq!(out5, to_field(r5) + (256 * to_field(lo5)) + (65536 * to_field(hi5)),
+                              "u64_mul column 5: split_carry hint does not recompose to the column sum");
+                            let out6 = col6 + to_field(lo5) + (256 * to_field(hi5));
+                            match #split_carry(out6) {
+                              (rl6, rc6, rh6) =>
+                                let r6 = u8_xor(u8_from_field_unsafe(rl6), 0u8);
+                                let lo6 = u8_xor(u8_from_field_unsafe(rc6), 0u8);
+                                let hi6 = u8_xor(u8_from_field_unsafe(rh6), 0u8);
+                                assert_eq!(out6, to_field(r6) + (256 * to_field(lo6)) + (65536 * to_field(hi6)),
+                                  "u64_mul column 6: split_carry hint does not recompose to the column sum");
+                                let out7 = col7 + to_field(lo6) + (256 * to_field(hi6));
+                                match #split_carry(out7) {
+                                  (rl7, rc7, rh7) =>
+                                    let r7 = u8_xor(u8_from_field_unsafe(rl7), 0u8);
+                                    let lo7 = u8_xor(u8_from_field_unsafe(rc7), 0u8);
+                                    let hi7 = u8_xor(u8_from_field_unsafe(rh7), 0u8);
+                                    assert_eq!(out7, to_field(r7) + (256 * to_field(lo7)) + (65536 * to_field(hi7)),
+                                      "u64_mul column 7: split_carry hint does not recompose to the column sum");
+                                    let out8 = col8 + to_field(lo7) + (256 * to_field(hi7));
+                                    match #split_carry(out8) {
+                                      (rl8, rc8, rh8) =>
+                                        let r8 = u8_xor(u8_from_field_unsafe(rl8), 0u8);
+                                        let lo8 = u8_xor(u8_from_field_unsafe(rc8), 0u8);
+                                        let hi8 = u8_xor(u8_from_field_unsafe(rh8), 0u8);
+                                        assert_eq!(out8, to_field(r8) + (256 * to_field(lo8)) + (65536 * to_field(hi8)),
+                                          "u64_mul column 8: split_carry hint does not recompose to the column sum");
+                                        let out9 = col9 + to_field(lo8) + (256 * to_field(hi8));
+                                        match #split_carry(out9) {
+                                          (rl9, rc9, rh9) =>
+                                            let r9 = u8_xor(u8_from_field_unsafe(rl9), 0u8);
+                                            let lo9 = u8_xor(u8_from_field_unsafe(rc9), 0u8);
+                                            let hi9 = u8_xor(u8_from_field_unsafe(rh9), 0u8);
+                                            assert_eq!(out9, to_field(r9) + (256 * to_field(lo9)) + (65536 * to_field(hi9)),
+                                              "u64_mul column 9: split_carry hint does not recompose to the column sum");
+                                            let out10 = col10 + to_field(lo9) + (256 * to_field(hi9));
+                                            match #split_carry(out10) {
+                                              (rl10, rc10, rh10) =>
+                                                let r10 = u8_xor(u8_from_field_unsafe(rl10), 0u8);
+                                                let lo10 = u8_xor(u8_from_field_unsafe(rc10), 0u8);
+                                                let hi10 = u8_xor(u8_from_field_unsafe(rh10), 0u8);
+                                                assert_eq!(out10, to_field(r10) + (256 * to_field(lo10)) + (65536 * to_field(hi10)),
+                                                  "u64_mul column 10: split_carry hint does not recompose to the column sum");
+                                                let out11 = col11 + to_field(lo10) + (256 * to_field(hi10));
+                                                match #split_carry(out11) {
+                                                  (rl11, rc11, rh11) =>
+                                                    let r11 = u8_xor(u8_from_field_unsafe(rl11), 0u8);
+                                                    let lo11 = u8_xor(u8_from_field_unsafe(rc11), 0u8);
+                                                    let hi11 = u8_xor(u8_from_field_unsafe(rh11), 0u8);
+                                                    assert_eq!(out11, to_field(r11) + (256 * to_field(lo11)) + (65536 * to_field(hi11)),
+                                                      "u64_mul column 11: split_carry hint does not recompose to the column sum");
+                                                    let out12 = col12 + to_field(lo11) + (256 * to_field(hi11));
+                                                    match #split_carry(out12) {
+                                                      (rl12, rc12, rh12) =>
+                                                        let r12 = u8_xor(u8_from_field_unsafe(rl12), 0u8);
+                                                        let lo12 = u8_xor(u8_from_field_unsafe(rc12), 0u8);
+                                                        let hi12 = u8_xor(u8_from_field_unsafe(rh12), 0u8);
+                                                        assert_eq!(out12, to_field(r12) + (256 * to_field(lo12)) + (65536 * to_field(hi12)),
+                                                          "u64_mul column 12: split_carry hint does not recompose to the column sum");
+                                                        let out13 = col13 + to_field(lo12) + (256 * to_field(hi12));
+                                                        match #split_carry(out13) {
+                                                          (rl13, rc13, rh13) =>
+                                                            let r13 = u8_xor(u8_from_field_unsafe(rl13), 0u8);
+                                                            let lo13 = u8_xor(u8_from_field_unsafe(rc13), 0u8);
+                                                            let hi13 = u8_xor(u8_from_field_unsafe(rh13), 0u8);
+                                                            assert_eq!(out13, to_field(r13) + (256 * to_field(lo13)) + (65536 * to_field(hi13)),
+                                                              "u64_mul column 13: split_carry hint does not recompose to the column sum");
+                                                            let out14 = col14 + to_field(lo13) + (256 * to_field(hi13));
+                                                            match #split_carry(out14) {
+                                                              (rl14, rc14, rh14) =>
+                                                                let r14 = u8_xor(u8_from_field_unsafe(rl14), 0u8);
+                                                                let lo14 = u8_xor(u8_from_field_unsafe(rc14), 0u8);
+                                                                let hi14 = u8_xor(u8_from_field_unsafe(rh14), 0u8);
+                                                                assert_eq!(out14, to_field(r14) + (256 * to_field(lo14)) + (65536 * to_field(hi14)),
+                                                                  "u64_mul column 14: split_carry hint does not recompose to the column sum");
+                                                                let r15 = u8_from_field_unsafe(to_field(lo14) + (256 * to_field(hi14)));
+                                                                ([r0, r1, r2, r3, r4, r5, r6, r7],
+                                                                 [r8, r9, r10, r11, r12, r13, r14, r15]),
+                                                            },
+                                                        },
+                                                    },
+                                                },
+                                            },
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        },
+    }
+  }
+
+  -- Mirror: BigUint::mul. Limb-wise schoolbook multiply.
+  fn klimbs_mul(a: KLimbs, b: KLimbs) -> KLimbs {
+    klimbs_mul_outer(a, b, store(ListNode.Nil), 0)
+  }
+
+  fn klimbs_mul_outer(a: KLimbs, b: KLimbs, acc: KLimbs, shift: G) -> KLimbs {
+    match load(a) {
+      ListNode.Nil => acc,
+      ListNode.Cons(a_limb, rest) =>
+        let prod = klimbs_mul_single(a_limb, b, [0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], store(ListNode.Nil));
+        let shifted = klimbs_shl_limbs(prod, shift);
+        let new_acc = klimbs_add(acc, shifted);
+        klimbs_mul_outer(rest, b, new_acc, shift + 1),
+    }
+  }
+
+  fn klimbs_mul_single(a_limb: U64, b: KLimbs, carry: U64, acc: KLimbs) -> KLimbs {
+    match load(b) {
+      ListNode.Nil =>
+        match u64_is_zero(carry) {
+          1 => acc,
+          0 => list_snoc(acc, carry),
+        },
+      ListNode.Cons(b_limb, rest) =>
+        match u64_mul(a_limb, b_limb) {
+          (lo, hi) =>
+            match u64_add(lo, carry) {
+              (sum, carry_out) =>
+                match u64_add(hi, [carry_out, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]) {
+                  (new_carry, _) =>
+                    let new_acc = list_snoc(acc, sum);
+                    klimbs_mul_single(a_limb, rest, new_carry, new_acc),
+                },
+            },
+        },
+    }
+  }
+
+  fn klimbs_shl_limbs(x: KLimbs, shift: G) -> KLimbs {
+    match shift {
+      0 => x,
+      _ =>
+        let prepended = store(ListNode.Cons([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], x));
+        klimbs_shl_limbs(prepended, shift - 1),
+    }
+  }
+
+  fn klimbs_is_zero(x: KLimbs) -> G {
+    match load(klimbs_normalize(x)) {
+      ListNode.Nil => 1,
+      _ => 0,
+    }
+  }
+
+  -- Unconstrained Aiur op `unconstrained_big_uint_div_mod(a, b) -> (q, r)`
+  -- pushes prover-supplied (q, r) into the trace map; no constraints emitted
+  -- by the op itself. Caller verifies `q*b + r == a` (under normalize) and
+  -- `r < b` when `b != 0`. For `b == 0` the op returns `(0, a)`; only the
+  -- `q*b + r == a` equality is required (which holds: `0*0 + a == a`).
+  --
+  -- Soundness on the prover-supplied bytes: pinned by the explicit
+  -- `klimbs_range_check`es below, NOT by the arithmetic. `u64_mul` was
+  -- rewritten to raw field products plus `#split_carry`, whose u8 checks
+  -- constrain the split OUTPUTS, not the input digits — and it
+  -- re-canonicalizes while multiplying, so a digit-wrong `q` still yields
+  -- a canonical `q*b` and sails through the equality below. That left the
+  -- quotient's VALUE pinned but its representation free, which is enough:
+  -- `klimbs_eq` compares limbs rather than values, so a digit-wrong
+  -- quotient makes `Nat.beq (Nat.div 300 1) 300` answer `false`.
+  -- Trailing junk limbs are caught by the post-normalize equality.
+  fn klimbs_div_mod(a: KLimbs, b: KLimbs) -> (KLimbs, KLimbs) {
+    let (q_hint, r_hint) = unconstrained_big_uint_div_mod(a, b);
+    -- Normalize the hint before anything reads it. The op is unconstrained,
+    -- so nothing stops the prover returning limb lists with trailing zeros,
+    -- and these values are returned to callers: `klimbs_gcd` feeds the
+    -- remainder straight back as the next DIVISOR, where a trailing zero
+    -- limb made the `r < b` test pass vacuously.
+    let q = klimbs_normalize(q_hint);
+    let r = klimbs_normalize(r_hint);
+    klimbs_range_check(q);
+    klimbs_range_check(r);
+    let qb = klimbs_mul(q, b);
+    let lhs = klimbs_normalize(klimbs_add(qb, r));
+    let rhs = klimbs_normalize(a);
+    -- Pins the unconstrained div/mod hint: q*b + r must equal a.
+    assert_eq!(lhs, rhs, "div/mod hint: q*b + r != a");
+    match klimbs_is_zero(b) {
+      1 =>
+        -- `q * 0 + r == a` pins r to a but leaves q entirely free, so
+        -- without this the prover picks any quotient for `n / 0` — enough
+        -- to fold `Nat.div 1 0` to 1 against Lean's `Nat.div_zero = 0`.
+        assert_eq!(klimbs_is_zero(q), 1,
+          "div/mod hint: division by zero must yield a zero quotient");
+        (q, r),
+      0 =>
+        -- r < b iff (r + 1) ≤ b. One klimbs_le on klimbs_succ(r); cheapest
+        -- of the sound variants empirically (vs `le(r,b)∧¬eq(r,b)` or
+        -- `¬le(b,r)`).
+        assert_eq!(klimbs_le(klimbs_succ(r), b), 1,
+          "div/mod hint: remainder is not less than the divisor");
+        (q, r),
+    }
+  }
+
+  fn klimbs_div(a: KLimbs, b: KLimbs) -> KLimbs {
+    match klimbs_div_mod(a, b) { (q, _) => q, }
+  }
+
+  fn klimbs_mod(a: KLimbs, b: KLimbs) -> KLimbs {
+    match klimbs_div_mod(a, b) { (_, r) => r, }
+  }
+
+  fn klimbs_gcd(a: KLimbs, b: KLimbs) -> KLimbs {
+    match klimbs_is_zero(b) {
+      1 => a,
+      0 => klimbs_gcd(b, klimbs_mod(a, b)),
+    }
+  }
+
+  -- Binary exponentiation. Replaces the old O(exp) recursive
+  -- `klimbs_mul(base, klimbs_pow(base, klimbs_dec(exp)))` body, which
+  -- created one per-fn memo row per exponent step and OOM'd for
+  -- non-trivial exponents. Recursion depth is `log2(exp)` — for
+  -- `exp = 2^32` that's 32 memo entries instead of 4 billion.
+  --
+  -- Both `klimbs_div2` (= `klimbs_div(exp, 2)`) and `klimbs_is_odd`
+  -- (= `klimbs_mod(exp, 2) != 0`) route through `klimbs_div_mod`, which
+  -- is itself native (unconstrained_big_uint_div_mod) — so the
+  -- division per step is O(1) work.
+  fn klimbs_pow(base: KLimbs, exp: KLimbs) -> KLimbs {
+    match klimbs_is_zero(exp) {
+      1 => store(ListNode.Cons([1u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], store(ListNode.Nil))),
+      0 =>
+        let two = store(ListNode.Cons([2u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], store(ListNode.Nil)));
+        let (half, r) = klimbs_div_mod(exp, two);
+        let sq = klimbs_pow(klimbs_normalize(klimbs_mul(base, base)), klimbs_normalize(half));
+        match klimbs_is_zero(r) {
+          1 => sq,
+          0 => klimbs_mul(base, sq),
+        },
+    }
+  }
+
+  -- Byte-wise AND on two U64 limbs.
+  fn u64_and(a: U64, b: U64) -> U64 {
+    let [a0, a1, a2, a3, a4, a5, a6, a7] = a;
+    let [b0, b1, b2, b3, b4, b5, b6, b7] = b;
+    [u8_and(a0, b0), u8_and(a1, b1), u8_and(a2, b2), u8_and(a3, b3),
+     u8_and(a4, b4), u8_and(a5, b5), u8_and(a6, b6), u8_and(a7, b7)]
+  }
+
+  fn u64_or(a: U64, b: U64) -> U64 {
+    let [a0, a1, a2, a3, a4, a5, a6, a7] = a;
+    let [b0, b1, b2, b3, b4, b5, b6, b7] = b;
+    [u8_or(a0, b0), u8_or(a1, b1), u8_or(a2, b2), u8_or(a3, b3),
+     u8_or(a4, b4), u8_or(a5, b5), u8_or(a6, b6), u8_or(a7, b7)]
+  }
+
+  fn u64_xor_kbits(a: U64, b: U64) -> U64 {
+    let [a0, a1, a2, a3, a4, a5, a6, a7] = a;
+    let [b0, b1, b2, b3, b4, b5, b6, b7] = b;
+    [u8_xor(a0, b0), u8_xor(a1, b1), u8_xor(a2, b2), u8_xor(a3, b3),
+     u8_xor(a4, b4), u8_xor(a5, b5), u8_xor(a6, b6), u8_xor(a7, b7)]
+  }
+
+  -- Mirror: BigUint::bitand. Walks parallel limbs; result length = min(len(a), len(b)).
+  fn klimbs_land(a: KLimbs, b: KLimbs) -> KLimbs {
+    match load(a) {
+      ListNode.Nil => store(ListNode.Nil),
+      ListNode.Cons(la, ra) =>
+        match load(b) {
+          ListNode.Nil => store(ListNode.Nil),
+          ListNode.Cons(lb, rb) =>
+            store(ListNode.Cons(u64_and(la, lb), klimbs_land(ra, rb))),
+        },
+    }
+  }
+
+  -- Mirror: BigUint::bitor. Result length = max(len(a), len(b)); shorter is zero-padded.
+  fn klimbs_lor(a: KLimbs, b: KLimbs) -> KLimbs {
+    match load(a) {
+      ListNode.Nil => b,
+      ListNode.Cons(la, ra) =>
+        match load(b) {
+          ListNode.Nil => a,
+          ListNode.Cons(lb, rb) =>
+            store(ListNode.Cons(u64_or(la, lb), klimbs_lor(ra, rb))),
+        },
+    }
+  }
+
+  -- Mirror: BigUint::bitxor. Result length = max(len(a), len(b)); zero-padded shorter.
+  fn klimbs_xor_op(a: KLimbs, b: KLimbs) -> KLimbs {
+    match load(a) {
+      ListNode.Nil => b,
+      ListNode.Cons(la, ra) =>
+        match load(b) {
+          ListNode.Nil => a,
+          ListNode.Cons(lb, rb) =>
+            store(ListNode.Cons(u64_xor_kbits(la, lb), klimbs_xor_op(ra, rb))),
+        },
+    }
+  }
+
+  -- Shift left by n bits via repeated multiplication by 2.
+  fn klimbs_shl(a: KLimbs, n: KLimbs) -> KLimbs {
+    let two = store(ListNode.Cons([2u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], store(ListNode.Nil)));
+    klimbs_mul(a, klimbs_pow(two, n))
+  }
+
+  -- Shift right by n bits via integer division by 2^n.
+  fn klimbs_shr(a: KLimbs, n: KLimbs) -> KLimbs {
+    let two = store(ListNode.Cons([2u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], store(ListNode.Nil)));
+    klimbs_div(a, klimbs_pow(two, n))
+  }
+⟧
+
+end IxVM
+
+end
diff --git a/Ix/IxVM/Kernel/Levels.lean b/Ix/IxVM/Kernel/Levels.lean
index 6f0252d78..914745e26 100644
--- a/Ix/IxVM/Kernel/Levels.lean
+++ b/Ix/IxVM/Kernel/Levels.lean
@@ -8,8 +8,8 @@ namespace IxVM
 
 /-! ## Level operations + literal equality + expr_inst_levels
 
-Mirror: src/ix/kernel/level.rs + literal-equality helpers from
-src/ix/kernel/expr.rs. Self-contained; new kernel modules
+Mirror: crates/kernel/src/level.rs + literal-equality helpers from
+crates/kernel/src/expr.rs. Self-contained; new kernel modules
 (Subst/Whnf/Infer/DefEq/Check) import from here.
 -/
 
@@ -58,7 +58,7 @@ def levels := ⟦
   }
 
   -- ============================================================================
-  -- Canonical level normalization (mirror: src/ix/kernel/level.rs
+  -- Canonical level normalization (mirror: crates/kernel/src/level.rs
   -- normalize_level / norm_level_eq / norm_level_le, itself a port of
   -- Lean4Lean's Level.Normalize with the documented subsumption and
   -- covers-split fixes).
@@ -388,7 +388,7 @@ def levels := ⟦
     }
   }
 
-  -- Phase 2 subsumption: drop contributions dominated by another entry
+  -- subsumption: drop contributions dominated by another entry
   -- whose path is a subset (active whenever the dominated one is).
   -- Each entry folds over the ORIGINAL (snapshot) list, mirroring the
   -- Rust snapshot semantics. Callers seed `snapshot` with the same list
diff --git a/Ix/IxVM/Kernel/NatPrim.lean b/Ix/IxVM/Kernel/NatPrim.lean
new file mode 100644
index 000000000..c84db6bff
--- /dev/null
+++ b/Ix/IxVM/Kernel/NatPrim.lean
@@ -0,0 +1,1797 @@
+module
+public import Ix.Aiur.Meta
+public import Ix.IxVM.KernelTypes
+public import Ix.IxVM.Kernel.Klimbs
+
+set_option maxRecDepth 8192
+
+public section
+
+namespace IxVM
+
+/-! ## Nat primitive dispatch
+
+Nat/Str/BitVec/decidable/native reduction, mirroring
+crates/kernel/src/primitive.rs. Recognizes Const-headed applications of
+Nat.succ / Nat.pred / Nat.add / Nat.sub / Nat.mul / Nat.div / Nat.mod /
+Nat.pow / Nat.gcd / Nat.land / Nat.lor / Nat.xor / Nat.shl / Nat.shr /
+Nat.beq / Nat.ble on Nat literals (or on Nat.zero / App(Nat.succ, ...)
+ctor chains) and reduces them to a Nat or Bool literal via the
+`klimbs_*` bignum ops.
+
+Recognition is by address: each primitive is identified by the 32-byte
+blake3 of its Ixon serialization, hardcoded below and read straight out
+of `Const(addr, _)`. Those literals are the kernel's entire notion of
+"this constant IS Nat.add", so a single wrong byte silently disables a
+primitive or misapplies one — `Tests/Ix/Kernel/PrimAddrs.lean` guards
+every one of them against the canonical table.
+
+Beyond literal-on-literal folding, the dispatch also produces "stuck
+compact forms" for symbolic bases (`Nat.add x 3`, `x / n`): reducing
+those to successor towers or unfolding the division algorithm is what
+makes naive Nat reduction explode, so they are kept in offset form and
+compared structurally instead.
+-/
+
+set_option maxRecDepth 16384 in
+def natPrim := ⟦
+  -- ============================================================================
+  -- Primitive canonical addresses. Guarded by Tests/Ix/Kernel/PrimAddrs.lean.
+  -- ============================================================================
+  fn nat_zero_addr() -> Addr {
+    store([0xd3u8, 0x97u8, 0x37u8, 0x01u8, 0x57u8, 0xfbu8, 0x9au8, 0xe2u8,
+     0xc6u8, 0xe1u8, 0xedu8, 0xa7u8, 0x9fu8, 0xebu8, 0x10u8, 0xbfu8,
+     0x49u8, 0x74u8, 0x01u8, 0x74u8, 0x1au8, 0xbau8, 0x78u8, 0x8fu8,
+     0xabu8, 0x72u8, 0x6cu8, 0xfau8, 0x4cu8, 0x46u8, 0x7du8, 0xb6u8])
+  }
+
+  fn nat_succ_addr() -> Addr {
+    store([0xdeu8, 0xf5u8, 0x2du8, 0x1du8, 0xadu8, 0x5fu8, 0x10u8, 0xcfu8,
+     0x98u8, 0x93u8, 0xc9u8, 0x45u8, 0xe1u8, 0x69u8, 0x71u8, 0x8du8,
+     0x62u8, 0xb1u8, 0x5eu8, 0x2du8, 0xd2u8, 0xc9u8, 0x06u8, 0x6eu8,
+     0x59u8, 0x7bu8, 0x9du8, 0x45u8, 0x70u8, 0xbau8, 0x05u8, 0x6eu8])
+  }
+
+  fn nat_pred_addr() -> Addr {
+    store([0x91u8, 0x4fu8, 0x9cu8, 0x01u8, 0x88u8, 0x48u8, 0x53u8, 0x65u8,
+     0x2eu8, 0x92u8, 0x24u8, 0xdcu8, 0x51u8, 0x1fu8, 0x86u8, 0x7du8,
+     0x54u8, 0x08u8, 0x51u8, 0x7fu8, 0x3bu8, 0xebu8, 0x31u8, 0x92u8,
+     0xfcu8, 0x44u8, 0x77u8, 0xe0u8, 0xe9u8, 0x59u8, 0x4cu8, 0x88u8])
+  }
+
+  fn nat_add_addr() -> Addr {
+    store([0xd6u8, 0xf6u8, 0x2au8, 0x97u8, 0x79u8, 0x10u8, 0x8fu8, 0x9fu8,
+     0xb6u8, 0xb6u8, 0x6bu8, 0x31u8, 0xccu8, 0x94u8, 0xc3u8, 0xd8u8,
+     0x4cu8, 0xa7u8, 0x2du8, 0x8bu8, 0xeau8, 0x18u8, 0x5eu8, 0x13u8,
+     0x13u8, 0x7cu8, 0x50u8, 0xc7u8, 0xefu8, 0x84u8, 0xc9u8, 0x69u8])
+  }
+
+  fn nat_sub_addr() -> Addr {
+    store([0xfdu8, 0xbdu8, 0x5fu8, 0xefu8, 0x40u8, 0x14u8, 0x9cu8, 0x85u8,
+     0x33u8, 0x3cu8, 0x6fu8, 0x3cu8, 0xceu8, 0xbbu8, 0x4bu8, 0xe7u8,
+     0x41u8, 0x27u8, 0x0du8, 0x20u8, 0x66u8, 0x33u8, 0x6cu8, 0xb2u8,
+     0xeeu8, 0xf8u8, 0x76u8, 0x23u8, 0x74u8, 0x4bu8, 0x72u8, 0xb0u8])
+  }
+
+  fn nat_mul_addr() -> Addr {
+    store([0x66u8, 0x49u8, 0x66u8, 0x56u8, 0x07u8, 0xb0u8, 0x75u8, 0x0cu8,
+     0x2cu8, 0xa7u8, 0x3fu8, 0x45u8, 0xdeu8, 0x60u8, 0x0fu8, 0x21u8,
+     0xcbu8, 0x67u8, 0x03u8, 0x98u8, 0x50u8, 0x48u8, 0x65u8, 0xbbu8,
+     0x97u8, 0x97u8, 0x24u8, 0x38u8, 0x01u8, 0x4fu8, 0x96u8, 0xd9u8])
+  }
+
+  fn nat_pow_addr() -> Addr {
+    store([0x33u8, 0xc6u8, 0x04u8, 0x45u8, 0x1du8, 0x01u8, 0xcbu8, 0x19u8,
+     0xa4u8, 0x33u8, 0x66u8, 0x82u8, 0x46u8, 0xb9u8, 0x8fu8, 0x6eu8,
+     0x87u8, 0x4bu8, 0xd6u8, 0x30u8, 0xb7u8, 0x8au8, 0x79u8, 0x1du8,
+     0x7au8, 0x37u8, 0x3au8, 0x97u8, 0x98u8, 0x49u8, 0xa1u8, 0xcfu8])
+  }
+
+  fn nat_gcd_addr() -> Addr {
+    store([0x3bu8, 0xe4u8, 0x83u8, 0x57u8, 0xaeu8, 0x17u8, 0xf7u8, 0x4du8,
+     0x4du8, 0xf2u8, 0x7du8, 0x69u8, 0x7au8, 0xedu8, 0x3fu8, 0x47u8,
+     0xc1u8, 0x30u8, 0x79u8, 0x41u8, 0xf4u8, 0x1au8, 0xffu8, 0xcfu8,
+     0x74u8, 0xdau8, 0x5fu8, 0x66u8, 0xd5u8, 0x11u8, 0xa7u8, 0x97u8])
+  }
+
+  fn nat_mod_addr() -> Addr {
+    store([0x51u8, 0x79u8, 0x63u8, 0x8bu8, 0x82u8, 0xccu8, 0x83u8, 0x37u8,
+     0x91u8, 0x4au8, 0x7bu8, 0xcau8, 0xadu8, 0x85u8, 0x8cu8, 0x85u8,
+     0x88u8, 0x88u8, 0x44u8, 0xe9u8, 0xa2u8, 0x92u8, 0x43u8, 0x0cu8,
+     0xacu8, 0x51u8, 0xe5u8, 0xeau8, 0xdcu8, 0x41u8, 0xa1u8, 0xafu8])
+  }
+
+  fn nat_div_addr() -> Addr {
+    store([0x89u8, 0xdeu8, 0xcau8, 0x86u8, 0xddu8, 0x8fu8, 0x00u8, 0x66u8,
+     0xa5u8, 0x06u8, 0x4fu8, 0xdbu8, 0x19u8, 0xa2u8, 0xc6u8, 0x89u8,
+     0x7au8, 0x3au8, 0x98u8, 0x67u8, 0xcau8, 0xadu8, 0xc0u8, 0x4fu8,
+     0x77u8, 0x8du8, 0x5cu8, 0x5cu8, 0xd0u8, 0x22u8, 0x53u8, 0x62u8])
+  }
+
+  fn nat_land_addr() -> Addr {
+    store([0x81u8, 0x8au8, 0xbbu8, 0x33u8, 0x11u8, 0x50u8, 0x40u8, 0x0du8,
+     0x10u8, 0xb3u8, 0x4fu8, 0xaeu8, 0x4du8, 0xfbu8, 0x94u8, 0x26u8,
+     0x74u8, 0x1cu8, 0x46u8, 0x07u8, 0xbau8, 0xeeu8, 0xd8u8, 0xd9u8,
+     0x62u8, 0x71u8, 0xbau8, 0x16u8, 0x59u8, 0x05u8, 0x8eu8, 0xf8u8])
+  }
+
+  fn nat_lor_addr() -> Addr {
+    store([0x9bu8, 0x76u8, 0xf3u8, 0x2bu8, 0xbbu8, 0x1du8, 0xbdu8, 0xf4u8,
+     0xffu8, 0x68u8, 0xe0u8, 0x22u8, 0x12u8, 0x25u8, 0x01u8, 0x5du8,
+     0xf0u8, 0xcau8, 0x2du8, 0x2au8, 0x60u8, 0x23u8, 0xc1u8, 0xa8u8,
+     0x13u8, 0x06u8, 0xd4u8, 0x02u8, 0x0du8, 0x4eu8, 0xf3u8, 0x97u8])
+  }
+
+  fn nat_xor_addr() -> Addr {
+    store([0x97u8, 0xe3u8, 0x25u8, 0xa9u8, 0x6au8, 0x6au8, 0x18u8, 0x27u8,
+     0x19u8, 0x4eu8, 0xebu8, 0x7du8, 0x2au8, 0xa0u8, 0xd9u8, 0x19u8,
+     0x21u8, 0x07u8, 0x3au8, 0xefu8, 0x9cu8, 0x2du8, 0x33u8, 0x3cu8,
+     0x24u8, 0x61u8, 0x3eu8, 0x9au8, 0xc9u8, 0x56u8, 0xedu8, 0x29u8])
+  }
+
+  fn nat_shift_left_addr() -> Addr {
+    store([0xdcu8, 0x81u8, 0xe4u8, 0x1cu8, 0xadu8, 0x11u8, 0x90u8, 0x37u8,
+     0x7du8, 0xbeu8, 0x60u8, 0x4bu8, 0xfcu8, 0x3au8, 0xfeu8, 0x65u8,
+     0x8au8, 0x41u8, 0x3bu8, 0x9au8, 0x2du8, 0xcfu8, 0xbcu8, 0xabu8,
+     0x79u8, 0xfau8, 0xd7u8, 0xb7u8, 0xa5u8, 0xcdu8, 0xd9u8, 0x54u8])
+  }
+
+  fn nat_shift_right_addr() -> Addr {
+    store([0x6du8, 0xb4u8, 0x93u8, 0x04u8, 0xbfu8, 0x0fu8, 0x5au8, 0xcbu8,
+     0xfdu8, 0x1du8, 0x9du8, 0x9au8, 0x0cu8, 0x1bu8, 0x7au8, 0xe2u8,
+     0x0eu8, 0xf9u8, 0x9du8, 0x07u8, 0x37u8, 0x88u8, 0x70u8, 0x56u8,
+     0x12u8, 0x9fu8, 0x5bu8, 0x5cu8, 0xb5u8, 0xa9u8, 0xbau8, 0x8au8])
+  }
+
+  fn nat_beq_addr() -> Addr {
+    store([0xa3u8, 0x4au8, 0xb2u8, 0xdau8, 0xbau8, 0x34u8, 0x83u8, 0x9eu8,
+     0x85u8, 0x1fu8, 0xa3u8, 0x67u8, 0x51u8, 0x24u8, 0x56u8, 0x6fu8,
+     0x9fu8, 0x4du8, 0xcdu8, 0xe5u8, 0x97u8, 0x34u8, 0x9eu8, 0xcdu8,
+     0x54u8, 0xaeu8, 0x32u8, 0xf8u8, 0x42u8, 0x4eu8, 0x44u8, 0xb8u8])
+  }
+
+  fn nat_ble_addr() -> Addr {
+    store([0xdeu8, 0x0bu8, 0xefu8, 0xa8u8, 0x4fu8, 0xaau8, 0x22u8, 0xd1u8,
+     0x39u8, 0x43u8, 0x79u8, 0xa0u8, 0xbau8, 0x67u8, 0x29u8, 0x6eu8,
+     0x11u8, 0x66u8, 0x60u8, 0xf7u8, 0x81u8, 0xb4u8, 0xebu8, 0x63u8,
+     0x9du8, 0xbbu8, 0xabu8, 0xa2u8, 0x00u8, 0xefu8, 0x2bu8, 0xf8u8])
+  }
+
+  fn bool_true_addr() -> Addr {
+    store([0xa2u8, 0x9au8, 0x63u8, 0x61u8, 0x76u8, 0xcfu8, 0x11u8, 0x35u8,
+     0xd0u8, 0x77u8, 0xebu8, 0x07u8, 0x47u8, 0x98u8, 0xf9u8, 0x00u8,
+     0x7cu8, 0x78u8, 0xe7u8, 0x80u8, 0x13u8, 0x83u8, 0xe9u8, 0xcfu8,
+     0xf3u8, 0x63u8, 0xbau8, 0xe5u8, 0xedu8, 0xf0u8, 0x57u8, 0x62u8])
+  }
+
+  fn bool_false_addr() -> Addr {
+    store([0xddu8, 0xa1u8, 0x2bu8, 0xcbu8, 0x33u8, 0x07u8, 0x27u8, 0xf6u8,
+     0xdfu8, 0xb8u8, 0x16u8, 0xbcu8, 0x97u8, 0x52u8, 0xaau8, 0xbdu8,
+     0x05u8, 0x20u8, 0xe6u8, 0x51u8, 0x5bu8, 0x79u8, 0xfcu8, 0x8au8,
+     0x5au8, 0x9eu8, 0x71u8, 0x38u8, 0x66u8, 0xf4u8, 0xc6u8, 0x3eu8])
+  }
+
+  -- Native primitives ()
+  fn system_platform_num_bits_addr() -> Addr {
+    store([0xcfu8, 0x86u8, 0x26u8, 0x35u8, 0x21u8, 0xd3u8, 0x45u8, 0xc3u8,
+     0x90u8, 0x76u8, 0x47u8, 0x3eu8, 0xcdu8, 0xb9u8, 0xf6u8, 0xfdu8,
+     0x41u8, 0x1bu8, 0x5bu8, 0x50u8, 0x3bu8, 0xceu8, 0x83u8, 0xe2u8,
+     0x31u8, 0x8bu8, 0xa3u8, 0xfbu8, 0x6fu8, 0x23u8, 0x76u8, 0xd8u8])
+  }
+
+  fn punit_size_of_1_addr() -> Addr {
+    store([0x7bu8, 0xd8u8, 0xe1u8, 0x9fu8, 0x47u8, 0xf6u8, 0xeau8, 0xe6u8,
+     0x20u8, 0xa5u8, 0xc3u8, 0x9fu8, 0x24u8, 0x3cu8, 0xe4u8, 0x15u8,
+     0xddu8, 0x6au8, 0x77u8, 0xf0u8, 0x95u8, 0x90u8, 0xf4u8, 0xc2u8,
+     0x27u8, 0xceu8, 0xf3u8, 0x63u8, 0x00u8, 0x7fu8, 0x40u8, 0x12u8])
+  }
+
+  -- Compiler-emitted native reduction primitives.
+  fn reduce_bool_addr() -> Addr {
+    store([0x1cu8, 0x17u8, 0x00u8, 0x98u8, 0xe2u8, 0x31u8, 0x43u8, 0xfdu8,
+     0x8fu8, 0xd6u8, 0x17u8, 0x2cu8, 0xefu8, 0xd2u8, 0xecu8, 0xeeu8,
+     0x30u8, 0x50u8, 0x72u8, 0xd2u8, 0x99u8, 0x11u8, 0x13u8, 0xcfu8,
+     0xc4u8, 0xd5u8, 0x28u8, 0x40u8, 0xa5u8, 0xa9u8, 0xfau8, 0x78u8])
+  }
+
+  fn reduce_nat_addr() -> Addr {
+    store([0x16u8, 0x85u8, 0x30u8, 0x76u8, 0xb0u8, 0xd9u8, 0x6du8, 0x35u8,
+     0x6du8, 0x85u8, 0x48u8, 0x5cu8, 0x56u8, 0xf3u8, 0x39u8, 0x80u8,
+     0x14u8, 0xb6u8, 0xa0u8, 0xf2u8, 0xeeu8, 0x72u8, 0xabu8, 0x16u8,
+     0x28u8, 0x4au8, 0x38u8, 0x1du8, 0x9cu8, 0x28u8, 0xe5u8, 0x60u8])
+  }
+
+  fn subtype_val_addr() -> Addr {
+    store([0x0bu8, 0x59u8, 0x58u8, 0xa3u8, 0xc8u8, 0x22u8, 0xc9u8, 0x9eu8,
+     0x86u8, 0x43u8, 0xa2u8, 0x7fu8, 0x0bu8, 0x92u8, 0x8du8, 0xfbu8,
+     0x82u8, 0xc4u8, 0x54u8, 0x47u8, 0xbeu8, 0xe0u8, 0x35u8, 0x3cu8,
+     0x20u8, 0x0au8, 0xd1u8, 0xb7u8, 0xd0u8, 0xe4u8, 0x60u8, 0x92u8])
+  }
+
+  fn system_platform_get_num_bits_addr() -> Addr {
+    store([0xf5u8, 0xd2u8, 0x56u8, 0xc1u8, 0xddu8, 0x79u8, 0x4du8, 0x02u8,
+     0xcfu8, 0xdfu8, 0x17u8, 0x62u8, 0xc9u8, 0xe4u8, 0x1bu8, 0x13u8,
+     0xabu8, 0xe5u8, 0xbdu8, 0xddu8, 0xe1u8, 0x2du8, 0x92u8, 0x9du8,
+     0x02u8, 0xadu8, 0xa3u8, 0x7eu8, 0x4fu8, 0x40u8, 0xe8u8, 0x5fu8])
+  }
+
+  fn size_of_size_of_addr() -> Addr {
+    store([0x38u8, 0x97u8, 0x15u8, 0xf9u8, 0x1eu8, 0x66u8, 0x68u8, 0x3du8,
+     0xc7u8, 0x10u8, 0x8cu8, 0xcdu8, 0x85u8, 0x3eu8, 0xfcu8, 0xe9u8,
+     0x29u8, 0x49u8, 0x51u8, 0x2fu8, 0xa6u8, 0x59u8, 0xadu8, 0x3cu8,
+     0x19u8, 0x02u8, 0xe7u8, 0x54u8, 0x69u8, 0x29u8, 0x19u8, 0xcdu8])
+  }
+
+  fn punit_addr() -> Addr {
+    store([0x2du8, 0xfcu8, 0x16u8, 0xafu8, 0x01u8, 0xb8u8, 0x2bu8, 0x3bu8,
+     0x91u8, 0xc2u8, 0xffu8, 0x70u8, 0x44u8, 0x09u8, 0xd7u8, 0x62u8,
+     0x36u8, 0xa8u8, 0x3fu8, 0x95u8, 0x6cu8, 0x0cu8, 0x6eu8, 0x66u8,
+     0x59u8, 0xa6u8, 0x4fu8, 0xe2u8, 0x1du8, 0x76u8, 0x69u8, 0x5bu8])
+  }
+
+  fn unit_addr() -> Addr {
+    store([0x92u8, 0x32u8, 0x49u8, 0x86u8, 0x67u8, 0xf7u8, 0x65u8, 0xf4u8,
+     0x37u8, 0xdeu8, 0xdau8, 0xacu8, 0x82u8, 0x8eu8, 0x55u8, 0x5fu8,
+     0x6cu8, 0xc6u8, 0x7au8, 0x20u8, 0xe6u8, 0xdbu8, 0x28u8, 0xf6u8,
+     0x14u8, 0xfdu8, 0xf3u8, 0xc2u8, 0x62u8, 0x71u8, 0x0fu8, 0xebu8])
+  }
+
+  fn is_native_prim_addr(a: Addr) -> G {
+    match address_eq(a, system_platform_num_bits_addr()) {
+      1 => 1,
+      _ =>
+      match address_eq(a, punit_size_of_1_addr()) {
+        1 => 1,
+        _ =>
+        match address_eq(a, reduce_bool_addr()) {
+          1 => 1,
+          _ =>
+          match address_eq(a, reduce_nat_addr()) {
+            1 => 1,
+            _ =>
+            match address_eq(a, subtype_val_addr()) {
+              1 => 1,
+              _ =>
+              match address_eq(a, size_of_size_of_addr()) {
+                1 => 1,
+                _ => 0,
+              },
+            },
+          },
+        },
+      },
+    }
+  }
+
+  fn mk_nat_literal_64() -> KExpr {
+    let limbs = store(ListNode.Cons(
+      [64u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], store(ListNode.Nil)));
+    store(KExprNode.Lit(KLiteral.Nat(limbs)))
+  }
+
+  fn mk_nat_one() -> KExpr {
+    let limbs = store(ListNode.Cons(
+      [1u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], store(ListNode.Nil)));
+    store(KExprNode.Lit(KLiteral.Nat(limbs)))
+  }
+
+  -- Native reduce dispatch.
+  --   numBits (nullary)      → Lit(Nat 64)
+  --   PUnit.SizeOf.1 (nul)   → Lit(Nat 1)
+  --   Lean.reduceBool arg    → whnf arg; accept Const(Bool.true|Bool.false)
+  --   Lean.reduceNat arg     → whnf arg; accept Lit(Nat _)
+  fn try_native_dispatch(head_addr: Addr, spine: List‹KExpr›,
+                             types: List‹KExpr›) -> (G, KExpr) {
+    match address_eq(head_addr, system_platform_num_bits_addr()) {
+      1 => (1, mk_nat_literal_64()),
+      _ =>
+      match address_eq(head_addr, punit_size_of_1_addr()) {
+        1 => (1, mk_nat_one()),
+        _ =>
+        match address_eq(head_addr, subtype_val_addr()) {
+          1 => try_reduce_subtype_val(spine),
+          _ =>
+          match address_eq(head_addr, size_of_size_of_addr()) {
+            1 => try_reduce_size_of_unit(spine),
+            _ =>
+              let is_rb = address_eq(head_addr, reduce_bool_addr());
+              let is_rn = address_eq(head_addr, reduce_nat_addr());
+              match is_rb + is_rn {
+                0 => (0, store(KExprNode.BVar(0))),
+                _ =>
+                  match u32_less_than(list_length(spine), 1) {
+                    1 => (0, store(KExprNode.BVar(0))),
+                    _ =>
+                      let arg = list_lookup(spine, 0);
+                      let result = whnf(arg, types);
+                      match is_rb {
+                        1 => check_native_bool(result),
+                        _ => check_native_nat(result),
+                      },
+                  },
+              },
+          },
+        },
+      },
+    }
+  }
+
+  -- Subtype.val A P (System.Platform.getNumBits ()) → 64.
+  -- Spine: [A, P, val_arg]. val_arg's spine head must = getNumBits.
+  fn try_reduce_subtype_val(spine: List‹KExpr›) -> (G, KExpr) {
+    match u32_less_than(list_length(spine), 3) {
+      1 => (0, store(KExprNode.BVar(0))),
+      _ =>
+        match collect_spine(list_lookup(spine, 2)) {
+          (head, _) =>
+            match load(head) {
+              KExprNode.Const(caddr, _) =>
+                match address_eq(caddr, system_platform_get_num_bits_addr()) {
+                  1 => (1, mk_nat_literal_64()),
+                  _ => (0, store(KExprNode.BVar(0))),
+                },
+              _ => (0, store(KExprNode.BVar(0))),
+            },
+        },
+    }
+  }
+
+  -- SizeOf.sizeOf.{u} Unit/PUnit ... → 1. First arg = type.
+  fn try_reduce_size_of_unit(spine: List‹KExpr›) -> (G, KExpr) {
+    match u32_less_than(list_length(spine), 1) {
+      1 => (0, store(KExprNode.BVar(0))),
+      _ =>
+        match collect_spine(list_lookup(spine, 0)) {
+          (head, _) =>
+            match load(head) {
+              KExprNode.Const(caddr, _) =>
+                match address_eq(caddr, unit_addr()) {
+                  1 => (1, mk_nat_one()),
+                  _ =>
+                    match address_eq(caddr, punit_addr()) {
+                      1 => (1, mk_nat_one()),
+                      _ => (0, store(KExprNode.BVar(0))),
+                    },
+                },
+              _ => (0, store(KExprNode.BVar(0))),
+            },
+        },
+    }
+  }
+
+  fn check_native_bool(e: KExpr) -> (G, KExpr) {
+    match load(e) {
+      KExprNode.Const(caddr, _) =>
+        let is_t = address_eq(caddr, bool_true_addr());
+        let is_f = address_eq(caddr, bool_false_addr());
+        match is_t + is_f {
+          0 => (0, store(KExprNode.BVar(0))),
+          _ => (1, e),
+        },
+      _ => (0, store(KExprNode.BVar(0))),
+    }
+  }
+
+  fn check_native_nat(e: KExpr) -> (G, KExpr) {
+    match load(e) {
+      KExprNode.Lit(lit) =>
+        match lit {
+          KLiteral.Nat(_) => (1, e),
+          _ => (0, store(KExprNode.BVar(0))),
+        },
+      _ => (0, store(KExprNode.BVar(0))),
+    }
+  }
+
+  -- BitVec primitives ()
+  fn bit_vec_to_nat_addr() -> Addr {
+    store([0x77u8, 0xa0u8, 0x25u8, 0xc1u8, 0x9fu8, 0x8bu8, 0xe1u8, 0x31u8,
+     0xfbu8, 0x9du8, 0x5bu8, 0x0bu8, 0xecu8, 0x49u8, 0x48u8, 0x17u8,
+     0xa2u8, 0x65u8, 0x38u8, 0xb9u8, 0xa5u8, 0x50u8, 0xabu8, 0xbbu8,
+     0xceu8, 0xc8u8, 0x09u8, 0x9fu8, 0xaeu8, 0x9du8, 0xe4u8, 0xe4u8])
+  }
+
+  fn bit_vec_of_nat_addr() -> Addr {
+    store([0x90u8, 0xcau8, 0x81u8, 0x30u8, 0x73u8, 0x5cu8, 0x8du8, 0x9au8,
+     0x34u8, 0x00u8, 0x5au8, 0x89u8, 0x43u8, 0xb5u8, 0x9fu8, 0xe1u8,
+     0xdfu8, 0x18u8, 0x2eu8, 0x08u8, 0xa9u8, 0xf2u8, 0xbfu8, 0xc7u8,
+     0xdcu8, 0x83u8, 0x23u8, 0x22u8, 0x96u8, 0x59u8, 0xa5u8, 0x74u8])
+  }
+
+  fn bit_vec_addr() -> Addr {
+    store([0x69u8, 0x8du8, 0xd5u8, 0x93u8, 0xabu8, 0xfbu8, 0x63u8, 0xdbu8,
+     0x36u8, 0x2au8, 0xaeu8, 0xf5u8, 0x7eu8, 0x70u8, 0xa7u8, 0x93u8,
+     0x04u8, 0x4fu8, 0xb6u8, 0x57u8, 0x25u8, 0x72u8, 0x91u8, 0xeeu8,
+     0x2cu8, 0x3eu8, 0x99u8, 0x7cu8, 0xaau8, 0x42u8, 0x3eu8, 0xaeu8])
+  }
+
+  fn bit_vec_ult_addr() -> Addr {
+    store([0x9fu8, 0xd8u8, 0xe7u8, 0x45u8, 0x9au8, 0x1du8, 0x2du8, 0xeeu8,
+     0xf0u8, 0x0au8, 0x49u8, 0x92u8, 0xa5u8, 0x04u8, 0x19u8, 0xbau8,
+     0xc6u8, 0x6cu8, 0x03u8, 0x08u8, 0x2bu8, 0x58u8, 0xadu8, 0xe0u8,
+     0x74u8, 0x22u8, 0x89u8, 0x6fu8, 0x13u8, 0x03u8, 0x3du8, 0x74u8])
+  }
+
+  fn decidable_decide_addr() -> Addr {
+    store([0xc5u8, 0xf7u8, 0xb1u8, 0x96u8, 0x63u8, 0xe4u8, 0x49u8, 0x9eu8,
+     0x70u8, 0xe1u8, 0xb2u8, 0x64u8, 0x51u8, 0x62u8, 0xc5u8, 0xbeu8,
+     0x15u8, 0xfau8, 0x86u8, 0x0fu8, 0x4fu8, 0x81u8, 0x57u8, 0xe3u8,
+     0x31u8, 0xaeu8, 0x54u8, 0x6cu8, 0x6fu8, 0x73u8, 0x37u8, 0x23u8])
+  }
+
+  fn lt_lt_addr() -> Addr {
+    store([0xcau8, 0xcau8, 0xeau8, 0x97u8, 0xf4u8, 0xcdu8, 0xbau8, 0x0au8,
+     0x4au8, 0x0au8, 0xf7u8, 0x10u8, 0x05u8, 0xd0u8, 0x51u8, 0x7du8,
+     0x18u8, 0x18u8, 0xabu8, 0x26u8, 0x23u8, 0xbdu8, 0x2eu8, 0xa7u8,
+     0xfau8, 0x8cu8, 0x63u8, 0x7au8, 0x0eu8, 0x3du8, 0x33u8, 0x12u8])
+  }
+
+  fn is_bitvec_prim_addr(a: Addr) -> G {
+    match address_eq(a, bit_vec_to_nat_addr()) {
+      1 => 1,
+      _ =>
+      match address_eq(a, bit_vec_ult_addr()) {
+        1 => 1,
+        _ =>
+        match address_eq(a, decidable_decide_addr()) {
+          1 => 1,
+          _ => 0,
+        },
+      },
+    }
+  }
+
+  -- Bool value (0/1) → Const(Bool.false/Bool.true).
+  fn mk_bool(g: G) -> KExpr {
+    match g {
+      0 => store(KExprNode.Const(bool_false_addr(), store(ListNode.Nil))),
+      _ => store(KExprNode.Const(bool_true_addr(), store(ListNode.Nil))),
+    }
+  }
+
+  -- Compute BitVec.toNat internally: given (width_e, val_e), returns
+  -- (1, N mod 2^W) as KLimbs. (0, _) on miss.
+  fn bv_to_nat_via(width_e: KExpr, val_e: KExpr) -> (G, KLimbs) {
+    match bitvec_of_nat_args_direct(val_e) {
+      (0, _, _) => (0, store(ListNode.Nil)),
+      (1, val_width, n_e) =>
+        match try_extract_nat(n_e) {
+          (0, _) => (0, store(ListNode.Nil)),
+          (1, n_kl) =>
+            match try_extract_nat(val_width) {
+              (0, _) => (0, store(ListNode.Nil)),
+              (1, w_kl) =>
+                let two = store(ListNode.Cons(
+                  [2u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8],
+                  store(ListNode.Nil)));
+                let modulus = klimbs_pow(two, w_kl);
+                (1, klimbs_normalize(klimbs_mod(n_kl, modulus))),
+            },
+        },
+    }
+  }
+
+  -- BitVec.ult width lhs rhs → mk_bool(lhs_nat < rhs_nat)
+  fn try_reduce_bit_vec_ult(spine: List‹KExpr›) -> (G, KExpr) {
+    match u32_less_than(list_length(spine), 3) {
+      1 => (0, store(KExprNode.BVar(0))),
+      _ =>
+        let width_e = list_lookup(spine, 0);
+        let lhs_e = list_lookup(spine, 1);
+        let rhs_e = list_lookup(spine, 2);
+        match bv_to_nat_via(width_e, lhs_e) {
+          (0, _) => (0, store(KExprNode.BVar(0))),
+          (1, lhs_n) =>
+            match bv_to_nat_via(width_e, rhs_e) {
+              (0, _) => (0, store(KExprNode.BVar(0))),
+              (1, rhs_n) =>
+                -- lhs < rhs iff !(rhs ≤ lhs)
+                let r = 1 - klimbs_le(rhs_n, lhs_n);
+                (1, mk_bool(r)),
+            },
+        },
+    }
+  }
+
+  -- decide (LT.lt BitVec width lhs rhs) inst → bit_vec_ult.
+  fn try_reduce_decide_bitvec_lt(spine: List‹KExpr›) -> (G, KExpr) {
+    match u32_less_than(list_length(spine), 2) {
+      1 => (0, store(KExprNode.BVar(0))),
+      _ =>
+        let prop = list_lookup(spine, 0);
+        match collect_spine(prop) {
+          (lt_head, lt_args) =>
+            match load(lt_head) {
+              KExprNode.Const(lt_caddr, _) =>
+                match address_eq(lt_caddr, lt_lt_addr()) {
+                  0 => (0, store(KExprNode.BVar(0))),
+                  _ =>
+                    match u32_less_than(list_length(lt_args), 4) {
+                      1 => (0, store(KExprNode.BVar(0))),
+                      _ =>
+                        let ty_arg = list_lookup(lt_args, 0);
+                        match collect_spine(ty_arg) {
+                          (ty_head, ty_args) =>
+                            match load(ty_head) {
+                              KExprNode.Const(ty_caddr, _) =>
+                                match address_eq(ty_caddr, bit_vec_addr()) {
+                                  0 => (0, store(KExprNode.BVar(0))),
+                                  _ =>
+                                    match u32_less_than(list_length(ty_args), 1) {
+                                      1 => (0, store(KExprNode.BVar(0))),
+                                      _ =>
+                                        let width = list_lookup(ty_args, 0);
+                                        let lhs = list_lookup(lt_args, 2);
+                                        let rhs = list_lookup(lt_args, 3);
+                                        let inner = store(ListNode.Cons(width,
+                                          store(ListNode.Cons(lhs,
+                                            store(ListNode.Cons(rhs,
+                                              store(ListNode.Nil)))))));
+                                        try_reduce_bit_vec_ult(inner),
+                                    },
+                                },
+                              _ => (0, store(KExprNode.BVar(0))),
+                            },
+                        },
+                    },
+                },
+              _ => (0, store(KExprNode.BVar(0))),
+            },
+        },
+    }
+  }
+
+  -- Extract (width, value) from `BitVec.ofNat W N` shape. Returns
+  -- (1, W, N) or (0, _, _). Direct form only: the `OfNat.ofNat`-wrapped
+  -- form is not recognized here, so a wrapped literal stays stuck rather
+  -- than folding.
+  fn bitvec_of_nat_args_direct(e: KExpr) -> (G, KExpr, KExpr) {
+    match collect_spine(e) {
+      (head, args) =>
+        match load(head) {
+          KExprNode.Const(caddr, _) =>
+            match address_eq(caddr, bit_vec_of_nat_addr()) {
+              1 =>
+                match list_length(args) - 2 {
+                  0 => (1, list_lookup(args, 0), list_lookup(args, 1)),
+                  _ => (0, store(KExprNode.BVar(0)), store(KExprNode.BVar(0))),
+                },
+              _ => (0, store(KExprNode.BVar(0)), store(KExprNode.BVar(0))),
+            },
+          _ => (0, store(KExprNode.BVar(0)), store(KExprNode.BVar(0))),
+        },
+    }
+  }
+
+  -- BitVec.toNat / BitVec.ult / decide(BitVec.lt) dispatch.
+  -- toNat + ult prep spine (whnf inner (W, N) args first). decide
+  -- inspects prop head shape — no pre-whnf (avoid cascading Defn
+  -- unfolds on arbitrary Prop args).
+  fn try_bitvec_dispatch(head_addr: Addr, spine: List‹KExpr›,
+                              types: List‹KExpr›) -> (G, KExpr) {
+    match address_eq(head_addr, bit_vec_to_nat_addr()) {
+      1 =>
+        match u32_less_than(list_length(spine), 2) {
+          1 => (0, store(KExprNode.BVar(0))),
+          _ =>
+            let spine_p = bitvec_prep_spine(spine, types);
+            let width_e = list_lookup(spine_p, 0);
+            let val_e = list_lookup(spine_p, 1);
+            match bv_to_nat_via(width_e, val_e) {
+              (0, _) => (0, store(KExprNode.BVar(0))),
+              (1, kl) => (1, mk_nat_lit(kl)),
+            },
+        },
+      _ =>
+        match address_eq(head_addr, bit_vec_ult_addr()) {
+          1 =>
+            let spine_p = bitvec_prep_spine_ult(spine, types);
+            try_reduce_bit_vec_ult(spine_p),
+          _ =>
+            match address_eq(head_addr, decidable_decide_addr()) {
+              1 => try_reduce_decide_bitvec_lt(spine),
+              _ => (0, store(KExprNode.BVar(0))),
+            },
+        },
+    }
+  }
+
+  -- BitVec.ult prep: whnf [width, lhs, rhs] and recursively whnf each
+  -- BitVec.ofNat inner args, mirror bitvec_prep_spine (toNat) shape.
+  fn bitvec_prep_spine_ult(spine: List‹KExpr›, types: List‹KExpr›)
+                                -> List‹KExpr› {
+    let sw = whnf_spine(spine, types);
+    match load(sw) {
+      ListNode.Nil => sw,
+      ListNode.Cons(width_e, r1) =>
+        match load(r1) {
+          ListNode.Nil => sw,
+          ListNode.Cons(lhs_e, r2) =>
+            match load(r2) {
+              ListNode.Nil => sw,
+              ListNode.Cons(rhs_e, tail) =>
+                let lhs_p = np_whnf_inner_bv(lhs_e, types);
+                let rhs_p = np_whnf_inner_bv(rhs_e, types);
+                store(ListNode.Cons(width_e,
+                  store(ListNode.Cons(lhs_p,
+                    store(ListNode.Cons(rhs_p, tail)))))),
+            },
+        },
+    }
+  }
+
+  -- If e = App*(head, args), whnf each arg once.
+  fn np_whnf_inner_bv(e: KExpr, types: List‹KExpr›) -> KExpr {
+    match collect_spine(e) {
+      (h, a) => apply_spine(h, whnf_spine(a, types)),
+    }
+  }
+
+  -- String primitives ()
+  fn string_utf8_byte_size_addr() -> Addr {
+    store([0xdeu8, 0xf4u8, 0x43u8, 0x3du8, 0x95u8, 0x47u8, 0xb5u8, 0x31u8,
+     0x75u8, 0xe2u8, 0x4au8, 0x3au8, 0xc1u8, 0x82u8, 0xc8u8, 0x8bu8,
+     0x07u8, 0x2au8, 0xf0u8, 0xd4u8, 0xadu8, 0x33u8, 0xfdu8, 0x04u8,
+     0xecu8, 0x4cu8, 0xf2u8, 0xbau8, 0x3du8, 0x95u8, 0xeau8, 0x93u8])
+  }
+
+  -- Native string-value fast paths (mirror crates/kernel/src/primitive.rs
+  -- `string_append` / `string_dec_eq`): literal append and literal
+  -- decidable equality reduce natively in whnf, keeping evaluator-grade
+  -- string values out of the structural ByteArray/UTF-8 model.
+  fn string_append_addr() -> Addr {
+    store([0x59u8, 0x4fu8, 0xb1u8, 0xeeu8, 0xdeu8, 0xc7u8, 0xc9u8, 0x39u8,
+     0xccu8, 0x87u8, 0x2bu8, 0x6cu8, 0x04u8, 0xccu8, 0x3bu8, 0x3eu8,
+     0x0au8, 0x97u8, 0x64u8, 0xfau8, 0xbeu8, 0xc3u8, 0xe6u8, 0x02u8,
+     0xadu8, 0x92u8, 0x14u8, 0xd0u8, 0xe6u8, 0x37u8, 0xd3u8, 0x0fu8])
+  }
+
+  fn string_of_list_addr() -> Addr {
+    store([0x96u8, 0x71u8, 0xfdu8, 0x4fu8, 0xcfu8, 0xbcu8, 0x06u8, 0x1cu8,
+     0x93u8, 0xc2u8, 0x82u8, 0x48u8, 0x64u8, 0xcfu8, 0x03u8, 0x12u8,
+     0x4fu8, 0xfeu8, 0xe7u8, 0xccu8, 0x22u8, 0x30u8, 0x8du8, 0xe1u8,
+     0x2au8, 0x7cu8, 0x82u8, 0x64u8, 0x73u8, 0xe4u8, 0x99u8, 0x06u8])
+  }
+
+  fn char_of_nat_addr() -> Addr {
+    store([0x1au8, 0x4cu8, 0x66u8, 0xf7u8, 0x67u8, 0x60u8, 0xf5u8, 0xefu8,
+     0x38u8, 0x6du8, 0xe0u8, 0x89u8, 0x68u8, 0x2au8, 0x55u8, 0xb7u8,
+     0x52u8, 0x13u8, 0x1eu8, 0x14u8, 0xa0u8, 0x85u8, 0x57u8, 0xc4u8,
+     0x46u8, 0x5eu8, 0xd1u8, 0x7fu8, 0xe0u8, 0xc4u8, 0xdcu8, 0x86u8])
+  }
+
+  fn list_nil_addr() -> Addr {
+    store([0x25u8, 0x8au8, 0x73u8, 0x64u8, 0xb8u8, 0x7cu8, 0x99u8, 0xfeu8,
+     0x9fu8, 0x83u8, 0xe0u8, 0x5eu8, 0x0du8, 0x05u8, 0xc9u8, 0x35u8,
+     0x60u8, 0x9au8, 0x0du8, 0xc5u8, 0xdfu8, 0x8du8, 0x77u8, 0x93u8,
+     0x91u8, 0x30u8, 0xefu8, 0xe5u8, 0xe0u8, 0xefu8, 0xcau8, 0x3eu8])
+  }
+
+  fn list_cons_addr() -> Addr {
+    store([0x77u8, 0xd5u8, 0x19u8, 0x25u8, 0x9eu8, 0xc9u8, 0xfau8, 0x48u8,
+     0x9du8, 0xbeu8, 0x0eu8, 0x3du8, 0xc0u8, 0xb9u8, 0x35u8, 0x2au8,
+     0xefu8, 0x34u8, 0x9cu8, 0xcdu8, 0xaau8, 0x73u8, 0xeau8, 0x58u8,
+     0xb0u8, 0x8bu8, 0xb0u8, 0xbcu8, 0x68u8, 0x35u8, 0x02u8, 0xa0u8])
+  }
+
+  fn char_type_addr() -> Addr {
+    store([0x29u8, 0xddu8, 0x2du8, 0x19u8, 0x86u8, 0xa5u8, 0x25u8, 0xbdu8,
+     0xdeu8, 0x49u8, 0xb4u8, 0xadu8, 0x2du8, 0xefu8, 0xc3u8, 0x49u8,
+     0xceu8, 0xc7u8, 0x1du8, 0x04u8, 0x84u8, 0xcdu8, 0x13u8, 0xf2u8,
+     0xdau8, 0x92u8, 0xf1u8, 0xfcu8, 0xe8u8, 0x9au8, 0x4cu8, 0x79u8])
+  }
+
+  fn string_back_addr() -> Addr {
+    store([0xe9u8, 0x5cu8, 0x8du8, 0x87u8, 0x6eu8, 0x7cu8, 0xcfu8, 0x78u8,
+     0x04u8, 0x18u8, 0x61u8, 0x5eu8, 0x33u8, 0xb7u8, 0x47u8, 0xa2u8,
+     0x45u8, 0xd9u8, 0x4fu8, 0xacu8, 0xd7u8, 0x56u8, 0x7fu8, 0xecu8,
+     0xbeu8, 0x7au8, 0xe7u8, 0x3au8, 0x5au8, 0xc0u8, 0x92u8, 0x06u8])
+  }
+
+  fn string_legacy_back_addr() -> Addr {
+    store([0x6bu8, 0xb6u8, 0x16u8, 0x2au8, 0xacu8, 0x7du8, 0x6au8, 0x01u8,
+     0xb6u8, 0xecu8, 0x05u8, 0x58u8, 0x06u8, 0x64u8, 0xe8u8, 0xa7u8,
+     0xf0u8, 0xd4u8, 0xb0u8, 0xecu8, 0x1fu8, 0xc5u8, 0xafu8, 0xaau8,
+     0xe6u8, 0x60u8, 0x18u8, 0xe9u8, 0xa1u8, 0x93u8, 0x6du8, 0xacu8])
+  }
+
+  fn string_to_byte_array_addr() -> Addr {
+    store([0xedu8, 0x43u8, 0xc7u8, 0x7eu8, 0x55u8, 0x55u8, 0x93u8, 0xb6u8,
+     0xcdu8, 0x0du8, 0x4bu8, 0xfbu8, 0xc4u8, 0x27u8, 0x3bu8, 0xa1u8,
+     0x22u8, 0xe1u8, 0xc0u8, 0xcdu8, 0xf1u8, 0x09u8, 0x05u8, 0x71u8,
+     0x61u8, 0x2au8, 0x95u8, 0x2fu8, 0x94u8, 0x1eu8, 0xadu8, 0xb1u8])
+  }
+
+  fn byte_array_empty_addr() -> Addr {
+    store([0x7cu8, 0xfbu8, 0xa8u8, 0xfau8, 0x95u8, 0x84u8, 0x7cu8, 0x21u8,
+     0x3au8, 0xa4u8, 0x06u8, 0x61u8, 0x10u8, 0xbau8, 0x01u8, 0xa9u8,
+     0x7fu8, 0xb5u8, 0x97u8, 0xdau8, 0xf2u8, 0x9fu8, 0x5cu8, 0x07u8,
+     0xf7u8, 0x23u8, 0x66u8, 0x07u8, 0x2fu8, 0x25u8, 0x07u8, 0x44u8])
+  }
+
+  fn string_dec_eq_addr() -> Addr {
+    store([0x82u8, 0xe5u8, 0x56u8, 0x8du8, 0x88u8, 0xe2u8, 0x4fu8, 0x24u8,
+     0xd5u8, 0xbeu8, 0xfau8, 0xc3u8, 0x0cu8, 0xe9u8, 0x15u8, 0x01u8,
+     0x0eu8, 0x92u8, 0x59u8, 0x6fu8, 0x55u8, 0xa8u8, 0x22u8, 0xe2u8,
+     0x9fu8, 0x48u8, 0x76u8, 0xeau8, 0x3au8, 0x57u8, 0x93u8, 0x94u8])
+  }
+
+  fn string_type_addr() -> Addr {
+    store([0x7au8, 0xb2u8, 0xd5u8, 0x2au8, 0xc5u8, 0x2fu8, 0xd1u8, 0xf5u8,
+     0x18u8, 0x09u8, 0xb7u8, 0x18u8, 0xe5u8, 0x3cu8, 0xd0u8, 0x58u8,
+     0xacu8, 0x4bu8, 0x50u8, 0xd6u8, 0x51u8, 0x50u8, 0xe7u8, 0x8au8,
+     0xe6u8, 0x19u8, 0x13u8, 0x9cu8, 0xcfu8, 0x13u8, 0xc8u8, 0xfdu8])
+  }
+
+  -- Address is a string primitive.
+  fn is_str_prim_addr(a: Addr) -> G {
+    match address_eq(a, string_utf8_byte_size_addr()) {
+      1 => 1,
+      _ =>
+      match address_eq(a, string_append_addr()) {
+        1 => 1,
+        _ =>
+        match address_eq(a, string_of_list_addr()) {
+          1 => 1,
+          _ =>
+          match address_eq(a, string_back_addr()) {
+            1 => 1,
+            _ =>
+            match address_eq(a, string_legacy_back_addr()) {
+              1 => 1,
+              _ =>
+              match address_eq(a, string_to_byte_array_addr()) {
+                1 => 1,
+                _ =>
+                match address_eq(a, string_dec_eq_addr()) {
+                  1 => 1,
+                  _ => 0,
+                },
+              },
+            },
+          },
+        },
+      },
+    }
+  }
+
+
+  -- String primitive dispatch. Handles:
+  -- - String.utf8ByteSize (Lit(Str))          -> Lit(Nat len)
+  -- - String.append (Lit(Str), Lit(Str))      -> Lit(Str concat)
+  -- - String.ofList / String.mk (char-list)   -> Lit(Str) via UTF-8 fold
+  -- Caller pre-whnfs spine's outermost args; the ofList arm recursively
+  -- whnfs Cons tails to reach further literal-ctor nodes.
+  fn try_str_dispatch(head_addr: Addr, spine: List‹KExpr›,
+                          types: List‹KExpr›) -> (G, KExpr) {
+    let spine_len = list_length(spine);
+    match address_eq(head_addr, string_of_list_addr()) {
+      1 =>
+        match spine_len {
+          1 =>
+            match walk_char_list_bytes(list_lookup(spine, 0), types) {
+              (1, bs) => (1, store(KExprNode.Lit(KLiteral.Str(bs)))),
+              (0, _) => (0, store(KExprNode.BVar(0))),
+            },
+          _ => (0, store(KExprNode.BVar(0))),
+        },
+      _ =>
+    match address_eq(head_addr, string_utf8_byte_size_addr()) {
+      1 =>
+        match u32_less_than(spine_len, 1) {
+          1 => (0, store(KExprNode.BVar(0))),
+          _ =>
+            let a0 = list_lookup(spine, 0);
+            match load(a0) {
+              KExprNode.Lit(lit) =>
+                match lit {
+                  KLiteral.Str(bs) =>
+                    -- The length must be a CANONICAL `KLimbs`, because
+                    -- `klimbs_eq` — behind `Nat.beq`/`Nat.decEq`/
+                    -- `literal_eq` — compares limbs without normalizing.
+                    -- `klimbs_from_g` range-checks and pins its byte
+                    -- decomposition (so a length >= 256 lands in the right
+                    -- limb instead of an out-of-range digit), and
+                    -- `klimbs_normalize` strips the all-zero limb so the
+                    -- empty string yields the canonical zero rather than
+                    -- `[[0;8]]`.
+                    let limbs =
+                      klimbs_normalize(klimbs_from_g(list_length(bs)));
+                    (1, store(KExprNode.Lit(KLiteral.Nat(limbs)))),
+                  _ => (0, store(KExprNode.BVar(0))),
+                },
+              _ => (0, store(KExprNode.BVar(0))),
+            },
+        },
+      _ =>
+    match address_eq(head_addr, string_back_addr()) {
+      1 => try_str_back(spine),
+      _ =>
+    match address_eq(head_addr, string_legacy_back_addr()) {
+      1 => try_str_back(spine),
+      _ =>
+    match address_eq(head_addr, string_to_byte_array_addr()) {
+      1 => try_str_to_byte_array(spine),
+      _ =>
+    match address_eq(head_addr, string_dec_eq_addr()) {
+      1 => try_str_dec_eq(head_addr, spine, types),
+      _ =>
+        match address_eq(head_addr, string_append_addr()) {
+          1 =>
+            match u32_less_than(spine_len, 2) {
+              1 => (0, store(KExprNode.BVar(0))),
+              _ =>
+                let a0 = list_lookup(spine, 0);
+                let a1 = list_lookup(spine, 1);
+                match load(a0) {
+                  KExprNode.Lit(la) =>
+                    match la {
+                      KLiteral.Str(sa) =>
+                        match load(a1) {
+                          KExprNode.Lit(lb) =>
+                            match lb {
+                              KLiteral.Str(sb) =>
+                                let joined = list_concat(sa, sb);
+                                (1, store(KExprNode.Lit(KLiteral.Str(joined)))),
+                              _ => (0, store(KExprNode.BVar(0))),
+                            },
+                          _ => (0, store(KExprNode.BVar(0))),
+                        },
+                      _ => (0, store(KExprNode.BVar(0))),
+                    },
+                  _ => (0, store(KExprNode.BVar(0))),
+                },
+            },
+          _ => (0, store(KExprNode.BVar(0))),
+        },
+    },
+    },
+    },
+    },
+    },
+    }
+  }
+
+  -- String.back / legacy_back over Lit(Str(bs)) →
+  -- App(Const(char_of_nat), Lit(Nat last_cp)). Empty bs → 65 ('A').
+  fn try_str_back(spine: List‹KExpr›) -> (G, KExpr) {
+    match u32_less_than(list_length(spine), 1) {
+      1 => (0, store(KExprNode.BVar(0))),
+      _ =>
+        match load(list_lookup(spine, 0)) {
+          KExprNode.Lit(lit) =>
+            match lit {
+              KLiteral.Str(bs) =>
+                let cp = utf8_last_codepoint(bs);
+                let cp_limbs = klimbs_from_g(cp);
+                let cp_lit = store(KExprNode.Lit(KLiteral.Nat(cp_limbs)));
+                let con = store(KExprNode.Const(char_of_nat_addr(),
+                                                 store(ListNode.Nil)));
+                (1, store(KExprNode.App(con, cp_lit))),
+              _ => (0, store(KExprNode.BVar(0))),
+            },
+          _ => (0, store(KExprNode.BVar(0))),
+        },
+    }
+  }
+
+  -- String.toByteArray on Lit(Str "")  →  Const(byte_array_empty).
+  -- Non-empty bails to structural (caller falls back to Defn unfold).
+  fn try_str_to_byte_array(spine: List‹KExpr›) -> (G, KExpr) {
+    match u32_less_than(list_length(spine), 1) {
+      1 => (0, store(KExprNode.BVar(0))),
+      _ =>
+        match load(list_lookup(spine, 0)) {
+          KExprNode.Lit(lit) =>
+            match lit {
+              KLiteral.Str(bs) =>
+                match load(bs) {
+                  ListNode.Nil =>
+                    (1, store(KExprNode.Const(byte_array_empty_addr(),
+                                                store(ListNode.Nil)))),
+                  _ => (0, store(KExprNode.BVar(0))),
+                },
+              _ => (0, store(KExprNode.BVar(0))),
+            },
+          _ => (0, store(KExprNode.BVar(0))),
+        },
+    }
+  }
+
+  -- Walk byte stream forward decoding UTF-8; return last codepoint.
+  -- Empty → 65 ('A') per Rust default.
+  -- Validate an entire byte stream as UTF-8, aborting on the first
+  -- malformed scalar. `utf8_decode_one` already rejects out-of-range
+  -- continuation bytes, stray continuations as leaders, and overlong
+  -- forms, so walking the stream with it is exactly the reference
+  -- kernels' `String::from_utf8` check at ingress.
+  --
+  -- Needed at Str-literal CONVERSION, not just during string reduction:
+  -- `KLiteral.Str` is typed `String` by `k_infer_lit` without inspecting
+  -- the bytes, so a literal that is never decoded would otherwise
+  -- typecheck as a `String` that no Lean `String` corresponds to.
+  fn utf8_validate(bs: ByteStream) {
+    match load(bs) {
+      ListNode.Nil => (),
+      ListNode.Cons(b0, rest) =>
+        match utf8_decode_one(b0, rest) {
+          (_, remaining) => utf8_validate(remaining),
+        },
+    }
+  }
+
+  fn utf8_last_codepoint(bs: ByteStream) -> G {
+    utf8_last_go(bs, 65)
+  }
+
+  fn utf8_last_go(bs: ByteStream, prev: G) -> G {
+    match load(bs) {
+      ListNode.Nil => prev,
+      ListNode.Cons(b0, rest) =>
+        match utf8_decode_one(b0, rest) {
+          (cp, remaining) => utf8_last_go(remaining, cp),
+        },
+    }
+  }
+
+  -- Decode one UTF-8 codepoint. Honors length prefix bits:
+  -- 0xxxxxxx → 1 byte; 110xxxxx 10xxxxxx → 2; 1110xxxx 10*2 → 3;
+  -- 11110xxx 10*3 → 4 bytes.
+  -- A UTF-8 continuation byte is `10xxxxxx`, i.e. in [0x80, 0xC0). Only
+  -- that range decodes to a 6-bit payload; matching the two valid-range
+  -- outcomes makes any other byte fall off the match and abort (the
+  -- kernel's reject). Both bounds are load-bearing for soundness, not
+  -- conformance nicety: a byte < 0x80 makes `to_field(b) - 128` wrap to a
+  -- ~2^64 field element, and a byte >= 0xC0 makes the payload spill into
+  -- [64,128), so e.g. `[0xC0, 0xC0]` would decode to codepoint 64 and
+  -- alias the valid char `'@'`.
+  fn utf8_cont(b: U8) -> G {
+    match u8_less_than(b, 128u8) {
+      0 =>
+        match u8_less_than(b, 192u8) {
+          1 => to_field(b) - 128,
+        },
+    }
+  }
+
+  -- Decode one UTF-8 scalar, validating just enough to be INJECTIVE: no
+  -- two distinct byte sequences may decode to the same codepoint, or the
+  -- expanded `String.ofList` forms alias and def_eq accepts a false string
+  -- equality. That requires (a) continuation bytes in range (`utf8_cont`),
+  -- and (b) the per-length overlong minimum, so a codepoint that has a
+  -- shorter valid encoding cannot also be produced by a longer one. The
+  -- reference kernels validate the whole blob as UTF-8 at ingress; this is
+  -- the same rejection, done per scalar. Surrogates and codepoints beyond
+  -- 0x10FFFF are NOT rejected here: they produce unique codepoints that no
+  -- valid char reaches, so they cannot alias, and the downstream
+  -- `Char.ofNat` scalar guard leaves them stuck rather than folding them
+  -- into a valid char.
+  fn utf8_decode_one(b0: U8, rest: ByteStream) -> (G, ByteStream) {
+    match u8_less_than(b0, 128u8) {
+      1 => (to_field(b0), rest),
+      _ =>
+        -- Reject stray continuation bytes [0x80, 0xC2) as leaders: [0x80,
+        -- 0xC0) are continuations, and 0xC0/0xC1 only ever encode overlong
+        -- two-byte forms. Valid multi-byte leaders are >= 0xC2.
+        match u8_less_than(b0, 194u8) {
+          0 =>
+            match u8_less_than(b0, 224u8) {
+              1 =>
+                match load(rest) {
+                  ListNode.Cons(b1, r1) =>
+                    -- Two-byte cp is >= 0x80 for every leader >= 0xC2, so
+                    -- no overlong is reachable once the leader is gated.
+                    let cp = (to_field(b0) - 192) * 64 + utf8_cont(b1);
+                    (cp, r1),
+                },
+              _ =>
+                match u8_less_than(b0, 240u8) {
+                  1 =>
+                    match load(rest) {
+                      ListNode.Cons(b1, r1) =>
+                        match load(r1) {
+                          ListNode.Cons(b2, r2) =>
+                            let cp = (to_field(b0) - 224) * 4096
+                                   + utf8_cont(b1) * 64
+                                   + utf8_cont(b2);
+                            -- Overlong: a real three-byte scalar is
+                            -- >= 0x800. Reject anything below (e.g.
+                            -- [0xE0,0x80,0x80] -> 0, which would alias
+                            -- the one-byte NUL).
+                            match u32_less_than(cp, 2048) {
+                              0 => (cp, r2),
+                            },
+                        },
+                    },
+                  _ =>
+                    match load(rest) {
+                      ListNode.Cons(b1, r1) =>
+                        match load(r1) {
+                          ListNode.Cons(b2, r2) =>
+                            match load(r2) {
+                              ListNode.Cons(b3, r3) =>
+                                let cp = (to_field(b0) - 240) * 262144
+                                       + utf8_cont(b1) * 4096
+                                       + utf8_cont(b2) * 64
+                                       + utf8_cont(b3);
+                                -- Overlong: a real four-byte scalar is
+                                -- >= 0x10000.
+                                match u32_less_than(cp, 65536) {
+                                  0 => (cp, r3),
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        },
+    }
+  }
+
+  -- Mirror of Rust `def_eq.rs::str_lit_to_constructor`. Expands
+  -- Lit(Str(bs)) to ctor form
+  -- `String.ofList (List.cons.{0} Char (Char.ofNat c) (... List.nil.{0} Char))`.
+  -- Emits the constants unconditionally, with no check that they are
+  -- present in the env: they are listed in `synthesizedPrimNames`, so the
+  -- harness always seeds their bytes.
+  fn str_lit_to_ctor(bs: ByteStream) -> KExpr {
+    let zero_lvl = store(KLevelNode.Zero);
+    let ulvls = store(ListNode.Cons(zero_lvl, store(ListNode.Nil)));
+    let nil_const = store(KExprNode.Const(list_nil_addr(), ulvls));
+    let cons_const = store(KExprNode.Const(list_cons_addr(), ulvls));
+    let char_const = store(KExprNode.Const(char_type_addr(), store(ListNode.Nil)));
+    let con_const = store(KExprNode.Const(char_of_nat_addr(), store(ListNode.Nil)));
+    let str_const = store(KExprNode.Const(string_of_list_addr(), store(ListNode.Nil)));
+    let nil_app = store(KExprNode.App(nil_const, char_const));
+    let cons_partial = store(KExprNode.App(cons_const, char_const));
+    let list_expr = build_char_list(bs, nil_app, cons_partial, con_const);
+    store(KExprNode.App(str_const, list_expr))
+  }
+
+  fn build_char_list(bs: ByteStream, nil_app: KExpr,
+                         cons_partial: KExpr, con_const: KExpr) -> KExpr {
+    match load(bs) {
+      ListNode.Nil => nil_app,
+      ListNode.Cons(b0, rest) =>
+        match utf8_decode_one(b0, rest) {
+          (cp, remaining) =>
+            let cp_limbs = klimbs_from_g(cp);
+            let cp_lit = store(KExprNode.Lit(KLiteral.Nat(cp_limbs)));
+            let char_val = store(KExprNode.App(con_const, cp_lit));
+            let with_head = store(KExprNode.App(cons_partial, char_val));
+            let tail = build_char_list(remaining, nil_app, cons_partial, con_const);
+            store(KExprNode.App(with_head, tail)),
+        },
+    }
+  }
+
+  -- Mirror str_lit_delta_step (Primitive.lean:3074): take ONE delta
+  -- step past `String.ofList` when it is a Defn, settling the body with
+  -- whnf_nd — a plain whnf of the ofList application would fold straight
+  -- back into the Str literal via the native ofList collapse.
+  fn str_lit_delta_step(expanded: KExpr, types: List‹KExpr›) -> KExpr {
+    match load(expanded) {
+      KExprNode.App(f, list_arg) =>
+        match load(f) {
+          KExprNode.Const(caddr, _) =>
+            let ci = load(get_ci(caddr));
+            match ci {
+              KConstantInfo.Defn(_, _, value, _, _) =>
+                let body = expr_inst_levels(value, store(ListNode.Nil));
+                match load(body) {
+                  KExprNode.Lam(_, lam_body) =>
+                    whnf_nd(expr_inst1(lam_body, list_arg, 0), types),
+                  _ => whnf_nd(store(KExprNode.App(body, list_arg)), types),
+                },
+              _ => expanded,
+            },
+          _ => expanded,
+        },
+      _ => expanded,
+    }
+  }
+
+  -- Lit(Str) → ctor form with the delta step; other exprs unchanged.
+  -- Mirror str_lit_to_ctor_app_or_self (Primitive.lean:3099).
+  fn str_lit_to_ctor_app_or_self(e: KExpr, types: List‹KExpr›) -> KExpr {
+    match load(e) {
+      KExprNode.Lit(lit) =>
+        match lit {
+          KLiteral.Str(bs) => str_lit_delta_step(str_lit_to_ctor(bs), types),
+          _ => e,
+        },
+      _ => e,
+    }
+  }
+
+  -- G (< 2^32) → single-limb KLimbs via prover-provided 4-byte split.
+  -- Pinned by u8 range checks + reconstruction assert. `x >= 2^32`
+  -- rejected (assert fails), not silently truncated.
+  fn split_u32(x: G) -> (G, G, G, G) {
+    match divmod_256(x, 0) {
+      (b0, q1) =>
+        match divmod_256(q1, 0) {
+          (b1, q2) =>
+            match divmod_256(q2, 0) {
+              (b2, q3) =>
+                match divmod_256(q3, 0) {
+                  (b3, _) => (b0, b1, b2, b3),
+                },
+            },
+        },
+    }
+  }
+
+  -- Convert G value (< 2^32) into single-limb KLimbs. The 4-byte
+  -- decomposition is a prover-provided (unconstrained) witness, pinned by
+  -- four u8 range checks + the reconstruction assert. `x >= 2^32` is
+  -- rejected (assert fails) rather than silently truncated.
+  fn klimbs_from_g(x: G) -> KLimbs {
+    match #split_u32(x) {
+      (rb0, rb1, rb2, rb3) =>
+        let b0 = u8_xor(u8_from_field_unsafe(rb0), 0u8);
+        let b1 = u8_xor(u8_from_field_unsafe(rb1), 0u8);
+        let b2 = u8_xor(u8_from_field_unsafe(rb2), 0u8);
+        let b3 = u8_xor(u8_from_field_unsafe(rb3), 0u8);
+        -- Pins the unconstrained byte-split hint: the four witnessed
+        -- bytes must recompose to exactly the field element they claim
+        -- to decompose.
+        assert_eq!(x, to_field(b0) + 256 * to_field(b1)
+                   + 65536 * to_field(b2) + 16777216 * to_field(b3),
+          "u32 byte split does not recompose to the original value");
+        store(ListNode.Cons([b0, b1, b2, b3, 0u8, 0u8, 0u8, 0u8],
+                            store(ListNode.Nil))),
+    }
+  }
+
+  -- Mirror walk_char_list_bytes: whnf `list`, expect a fully applied
+  -- `List.nil` (1 lvl arg) or `List.cons` (1 lvl + head + tail).
+  -- Returns (0, _) on any non-literal-ctor node, wrong arity, or invalid
+  -- codepoint — caller falls back to structural.
+  fn walk_char_list_bytes(list: KExpr, types: List‹KExpr›)
+                              -> (G, ByteStream) {
+    let w = whnf(list, types);
+    match collect_spine(w) {
+      (head, args) =>
+        match load(head) {
+          KExprNode.Const(caddr, _) =>
+            match address_eq(caddr, list_nil_addr()) {
+              1 =>
+                match list_length(args) {
+                  1 => (1, store(ListNode.Nil)),
+                  _ => (0, store(ListNode.Nil)),
+                },
+              _ =>
+                match address_eq(caddr, list_cons_addr()) {
+                  0 => (0, store(ListNode.Nil)),
+                  _ =>
+                    match list_length(args) {
+                      3 =>
+                        match char_lit_codepoint(list_lookup(args, 1), types) {
+                          (0, _) => (0, store(ListNode.Nil)),
+                          (1, cp) =>
+                            match walk_char_list_bytes(list_lookup(args, 2), types) {
+                              (0, t) => (0, t),
+                              (1, t) => (1, utf8_encode_prepend(cp, t)),
+                            },
+                        },
+                      _ => (0, store(ListNode.Nil)),
+                    },
+                },
+            },
+          _ => (0, store(ListNode.Nil)),
+        },
+    }
+  }
+
+  -- Recognize App(Const(Char.ofNat), Nat-lit). Retry once through whnf
+  -- when the syntactic match misses (mirror char_lit_value +
+  -- whnf_prim_arg).
+  fn char_lit_codepoint(e: KExpr, types: List‹KExpr›) -> (G, G) {
+    match char_lit_codepoint_syn(e) {
+      (1, cp) => (1, cp),
+      _ =>
+        let w = whnf(e, types);
+        char_lit_codepoint_syn(w),
+    }
+  }
+
+  fn char_lit_codepoint_syn(e: KExpr) -> (G, G) {
+    match load(e) {
+      KExprNode.App(f, arg) =>
+        match load(f) {
+          KExprNode.Const(caddr, _) =>
+            match address_eq(caddr, char_of_nat_addr()) {
+              0 => (0, 0),
+              _ =>
+                match load(arg) {
+                  KExprNode.Lit(lit) =>
+                    match lit {
+                      KLiteral.Nat(limbs) => klimbs_scalar_value(limbs),
+                      _ => (0, 0),
+                    },
+                  _ => (0, 0),
+                },
+            },
+          _ => (0, 0),
+        },
+      _ => (0, 0),
+    }
+  }
+
+  -- Single-limb KLimbs → codepoint; multi-limb literals bail. Guards
+  -- to valid Unicode scalars (rejects surrogates 0xD800-0xDFFF and
+  -- codepoints ≥ 0x110000).
+  fn klimbs_scalar_value(limbs: KLimbs) -> (G, G) {
+    match load(limbs) {
+      ListNode.Cons(limb, rest) =>
+        match load(rest) {
+          ListNode.Nil =>
+            let [b0, b1, b2, b3, b4, b5, b6, b7] = limb;
+            let hi = to_field(b3) + to_field(b4) + to_field(b5) + to_field(b6) + to_field(b7);
+            match eq_zero(hi) {
+              0 => (0, 0),
+              _ =>
+                let cp = to_field(b0) + to_field(b1) * 256 + to_field(b2) * 65536;
+                match u32_less_than(cp, 55296) {
+                  1 => (1, cp),
+                  _ =>
+                    match u32_less_than(57343, cp) {
+                      0 => (0, 0),
+                      _ =>
+                        match u32_less_than(cp, 1114112) {
+                          1 => (1, cp),
+                          _ => (0, 0),
+                        },
+                    },
+                },
+            },
+          _ => (0, 0),
+        },
+      _ => (0, 0),
+    }
+  }
+
+  -- Off-circuit 6-bit decomposition (repeated subtraction); prover-
+  -- provided results MUST be pinned by u8 + window range checks +
+  -- reconstruction assert.
+  fn divmod_64u(x: G, q: G) -> (G, G) {
+    match u32_less_than(x, 64) {
+      1 => (x, q),
+      _ => divmod_64u(x - 64, q + 1),
+    }
+  }
+
+  fn utf8_groups(cp: G) -> (G, G, G, G) {
+    match divmod_64u(cp, 0) {
+      (g0, q1) =>
+        match divmod_64u(q1, 0) {
+          (g1, q2) =>
+            match divmod_64u(q2, 0) {
+              (g2, g3) => (g0, g1, g2, g3),
+            },
+        },
+    }
+  }
+
+  -- Constrained UTF-8 encode of a valid scalar `cp`, prepended to `tail`.
+  -- Length class chosen by u32_less_than compares on `cp` (already valid
+  -- per caller — no overlong branch).
+  fn utf8_encode_prepend(cp: G, tail: ByteStream) -> ByteStream {
+    match #utf8_groups(cp) {
+      (g0, g1, g2, g3) =>
+        let g0u = u8_xor(u8_from_field_unsafe(g0), 0u8);
+        let g1u = u8_xor(u8_from_field_unsafe(g1), 0u8);
+        let g2u = u8_xor(u8_from_field_unsafe(g2), 0u8);
+        let g3u = u8_xor(u8_from_field_unsafe(g3), 0u8);
+        let f0 = to_field(g0u);
+        let f1 = to_field(g1u);
+        let f2 = to_field(g2u);
+        let f3 = to_field(g3u);
+        -- Pins the unconstrained UTF-8 group hint: each group is a
+        -- 6-bit value and together they recompose to the codepoint.
+        assert_eq!(u32_less_than(f0, 64), 1,
+          "utf8 group 0 is not a 6-bit value");
+        assert_eq!(u32_less_than(f1, 64), 1,
+          "utf8 group 1 is not a 6-bit value");
+        assert_eq!(u32_less_than(f2, 64), 1,
+          "utf8 group 2 is not a 6-bit value");
+        assert_eq!(u32_less_than(f3, 64), 1,
+          "utf8 group 3 is not a 6-bit value");
+        assert_eq!(cp, f0 + f1 * 64 + f2 * 4096 + f3 * 262144,
+          "utf8 groups do not recompose to the codepoint");
+        match u32_less_than(cp, 128) {
+          1 => store(ListNode.Cons(u8_from_field_unsafe(cp), tail)),
+          _ =>
+            match u32_less_than(cp, 2048) {
+              1 =>
+                let t1 = u8_from_field_unsafe(f0 + 128);
+                let l1 = u8_from_field_unsafe(f1 + 192);
+                store(ListNode.Cons(l1, store(ListNode.Cons(t1, tail)))),
+              _ =>
+                match u32_less_than(cp, 65536) {
+                  1 =>
+                    let t2 = u8_from_field_unsafe(f0 + 128);
+                    let t1 = u8_from_field_unsafe(f1 + 128);
+                    let l2 = u8_from_field_unsafe(f2 + 224);
+                    store(ListNode.Cons(l2, store(ListNode.Cons(t1, store(ListNode.Cons(t2, tail)))))),
+                  _ =>
+                    let t3 = u8_from_field_unsafe(f0 + 128);
+                    let t2 = u8_from_field_unsafe(f1 + 128);
+                    let t1 = u8_from_field_unsafe(f2 + 128);
+                    let l3 = u8_from_field_unsafe(f3 + 240);
+                    store(ListNode.Cons(l3, store(ListNode.Cons(t1, store(ListNode.Cons(t2, store(ListNode.Cons(t3, tail)))))))),
+                },
+            },
+        },
+    }
+  }
+
+  -- ============================================================================
+  -- Family classification
+  -- ============================================================================
+  fn is_nat_prim_addr(a: Addr) -> G {
+    match address_eq(a, nat_succ_addr()) {
+      1 => 1,
+      _ =>
+      match address_eq(a, nat_pred_addr()) {
+        1 => 1,
+        _ =>
+        match address_eq(a, nat_add_addr()) {
+          1 => 1,
+          _ =>
+          match address_eq(a, nat_sub_addr()) {
+            1 => 1,
+            _ =>
+            match address_eq(a, nat_mul_addr()) {
+              1 => 1,
+              _ =>
+              match address_eq(a, nat_div_addr()) {
+                1 => 1,
+                _ =>
+                match address_eq(a, nat_mod_addr()) {
+                  1 => 1,
+                  _ =>
+                  match address_eq(a, nat_pow_addr()) {
+                    1 => 1,
+                    _ =>
+                    match address_eq(a, nat_gcd_addr()) {
+                      1 => 1,
+                      _ =>
+                      match address_eq(a, nat_beq_addr()) {
+                        1 => 1,
+                        _ =>
+                        match address_eq(a, nat_ble_addr()) {
+                          1 => 1,
+                          _ =>
+                          match address_eq(a, nat_land_addr()) {
+                            1 => 1,
+                            _ =>
+                            match address_eq(a, nat_lor_addr()) {
+                              1 => 1,
+                              _ =>
+                              match address_eq(a, nat_xor_addr()) {
+                                1 => 1,
+                                _ =>
+                                match address_eq(a, nat_shift_left_addr()) {
+                                  1 => 1,
+                                  _ =>
+                                  match address_eq(a, nat_shift_right_addr()) {
+                                    1 => 1,
+                                    _ => 0,
+                                  },
+                                },
+                              },
+                            },
+                          },
+                        },
+                      },
+                    },
+                  },
+                },
+              },
+            },
+          },
+        },
+      },
+    }
+  }
+
+  -- ============================================================================
+  -- Extract Nat literal from KExpr
+  -- ============================================================================
+  fn try_extract_nat(e: KExpr) -> (G, KLimbs) {
+    match load(e) {
+      KExprNode.Lit(lit) =>
+        match lit {
+          KLiteral.Nat(limbs) => (1, limbs),
+          _ => (0, store(ListNode.Nil)),
+        },
+      KExprNode.Const(caddr, _) =>
+        match address_eq(caddr, nat_zero_addr()) {
+          1 => (1, store(ListNode.Nil)),
+          _ => (0, store(ListNode.Nil)),
+        },
+      KExprNode.App(f, a) => try_extract_nat_app(f, a),
+      _ => (0, store(ListNode.Nil)),
+    }
+  }
+
+  -- Cold-extracted App arm: list_lookup + address_eq + recursive
+  -- try_extract_nat + klimbs_succ is the widest arm; pulling it out lets
+  -- `try_extract_nat`'s main width drop to the leaf-arm width.
+  fn try_extract_nat_app(f: KExpr, a: KExpr) -> (G, KLimbs) {
+    match load(f) {
+      KExprNode.Const(caddr, _) =>
+        match address_eq(caddr, nat_succ_addr()) {
+          1 =>
+            match try_extract_nat(a) {
+              (1, pred_limbs) => (1, klimbs_succ(pred_limbs)),
+              _ => (0, store(ListNode.Nil)),
+            },
+          _ => (0, store(ListNode.Nil)),
+        },
+      _ => (0, store(ListNode.Nil)),
+    }
+  }
+
+  fn mk_nat_lit(n: KLimbs) -> KExpr {
+    store(KExprNode.Lit(KLiteral.Nat(n)))
+  }
+
+  -- ============================================================================
+  -- Apply spine (rebuild App chain).
+  -- ============================================================================
+  fn np_apply_spine(head: KExpr, spine: List‹KExpr›) -> KExpr {
+    match load(spine) {
+      ListNode.Nil => head,
+      ListNode.Cons(a, rest) =>
+        np_apply_spine(store(KExprNode.App(head, a)), rest),
+    }
+  }
+
+  -- ============================================================================
+  -- Binop dispatch by head address on two literal args.
+  -- ============================================================================
+  fn try_nat_binop_addr(head_addr: Addr, a: KLimbs, b: KLimbs) -> (G, KExpr) {
+    match address_eq(head_addr, nat_add_addr()) {
+      1 => (1, mk_nat_lit(klimbs_normalize(klimbs_add(a, b)))),
+      _ =>
+      match address_eq(head_addr, nat_sub_addr()) {
+        1 => (1, mk_nat_lit(klimbs_normalize(klimbs_sub(a, b)))),
+        _ =>
+        match address_eq(head_addr, nat_mul_addr()) {
+          1 => (1, mk_nat_lit(klimbs_normalize(klimbs_mul(a, b)))),
+          _ =>
+          match address_eq(head_addr, nat_div_addr()) {
+            1 => (1, mk_nat_lit(klimbs_normalize(klimbs_div(a, b)))),
+            _ =>
+            match address_eq(head_addr, nat_mod_addr()) {
+              1 => (1, mk_nat_lit(klimbs_normalize(klimbs_mod(a, b)))),
+              _ =>
+              match address_eq(head_addr, nat_gcd_addr()) {
+                1 => (1, mk_nat_lit(klimbs_normalize(klimbs_gcd(a, b)))),
+                _ =>
+                match address_eq(head_addr, nat_pow_addr()) {
+                  1 => (1, mk_nat_lit(klimbs_normalize(klimbs_pow(a, b)))),
+                  _ =>
+                  match address_eq(head_addr, nat_land_addr()) {
+                    1 => (1, mk_nat_lit(klimbs_normalize(klimbs_land(a, b)))),
+                    _ =>
+                    match address_eq(head_addr, nat_lor_addr()) {
+                      1 => (1, mk_nat_lit(klimbs_normalize(klimbs_lor(a, b)))),
+                      _ =>
+                      match address_eq(head_addr, nat_xor_addr()) {
+                        1 => (1, mk_nat_lit(klimbs_normalize(klimbs_xor_op(a, b)))),
+                        _ =>
+                        match address_eq(head_addr, nat_shift_left_addr()) {
+                          1 => (1, mk_nat_lit(klimbs_normalize(klimbs_shl(a, b)))),
+                          _ =>
+                          match address_eq(head_addr, nat_shift_right_addr()) {
+                            1 => (1, mk_nat_lit(klimbs_normalize(klimbs_shr(a, b)))),
+                            _ =>
+                            match address_eq(head_addr, nat_beq_addr()) {
+                              1 => (1, mk_bool(klimbs_eq(a, b))),
+                              _ =>
+                              match address_eq(head_addr, nat_ble_addr()) {
+                                1 => (1, mk_bool(klimbs_le(a, b))),
+                                _ => (0, store(KExprNode.BVar(0))),
+                              },
+                            },
+                          },
+                        },
+                      },
+                    },
+                  },
+                },
+              },
+            },
+          },
+        },
+      },
+    }
+  }
+
+  -- ============================================================================
+  -- : nat_offset canonicalization + linear-rec fast path
+  -- ============================================================================
+
+  -- If head is Const(nat_add) applied to 2 args with rhs a Lit(Nat),
+  -- return (1, lhs, limbs). Else (0, _, _).
+  fn try_match_nat_add(head: KExpr, args: List‹KExpr›) -> (G, KExpr, KLimbs) {
+    match load(head) {
+      KExprNode.Const(caddr, _) =>
+        match address_eq(caddr, nat_add_addr()) {
+          0 => (0, head, store(ListNode.Nil)),
+          _ =>
+            match list_length(args) - 2 {
+              0 =>
+                let lhs = list_lookup(args, 0);
+                let rhs = list_lookup(args, 1);
+                match load(rhs) {
+                  KExprNode.Lit(lit) =>
+                    match lit {
+                      KLiteral.Nat(limbs) => (1, lhs, limbs),
+                      _ => (0, head, store(ListNode.Nil)),
+                    },
+                  _ => (0, head, store(ListNode.Nil)),
+                },
+              _ => (0, head, store(ListNode.Nil)),
+            },
+        },
+      _ => (0, head, store(ListNode.Nil)),
+    }
+  }
+
+  -- Build `Nat.succ pred` where pred = base if lit==1,
+  -- else `Nat.add base (Lit lit-1)`.
+  fn build_succ_offset(base: KExpr, lit: KLimbs) -> KExpr {
+    let one = store(ListNode.Cons([1u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8],
+                                  store(ListNode.Nil)));
+    let pred_lit_norm = klimbs_normalize(klimbs_sub(lit, one));
+    let succ_const = store(KExprNode.Const(nat_succ_addr(), store(ListNode.Nil)));
+    match klimbs_is_zero(pred_lit_norm) {
+      1 => store(KExprNode.App(succ_const, base)),
+      _ =>
+        let add_const = store(KExprNode.Const(nat_add_addr(), store(ListNode.Nil)));
+        let pred_lit_expr = store(KExprNode.Lit(KLiteral.Nat(pred_lit_norm)));
+        let pred = store(KExprNode.App(
+          store(KExprNode.App(add_const, base)),
+          pred_lit_expr));
+        store(KExprNode.App(succ_const, pred)),
+    }
+  }
+
+  -- Expose one Nat.succ layer if `e` matches `Nat.add base (Lit n)` with
+  -- n > 0. Enables iota to fire on the exposed successor without
+  -- unfolding into an n-deep succ tower. Non-matching inputs pass through.
+  fn cleanup_nat_offset_major(e: KExpr) -> KExpr {
+    match load(e) {
+      KExprNode.Lit(_) => e,
+      _ =>
+        match collect_spine(e) {
+          (head, args) =>
+            match load(head) {
+              KExprNode.Const(_, _) =>
+                match try_match_nat_add(head, args) {
+                  (1, base, lit) =>
+                    let lit_norm = klimbs_normalize(lit);
+                    match klimbs_is_zero(lit_norm) {
+                      1 => e,
+                      _ => build_succ_offset(base, lit_norm),
+                    },
+                  _ => e,
+                },
+              _ => e,
+            },
+        },
+    }
+  }
+
+  -- Build the compact stuck offset `Nat.add base (Lit n)` applied to
+  -- `post`. n = 0 collapses to bare `base`. Used by try_nat_linear_rec
+  -- to keep symbolic-base Nat.rec reductions in a memoizable
+  -- canonical form (defeq collapses across `Nat.add base k` with the
+  -- same base + k).
+  fn mk_nat_offset_stuck(base_w: KExpr, n: KLimbs,
+                              post: List‹KExpr›) -> (G, KExpr) {
+    match klimbs_is_zero(n) {
+      1 => (1, np_apply_spine(base_w, post)),
+      _ =>
+        let add_const = store(KExprNode.Const(nat_add_addr(), store(ListNode.Nil)));
+        let off = store(KExprNode.App(
+          store(KExprNode.App(add_const, base_w)),
+          mk_nat_lit(n)));
+        (1, np_apply_spine(off, post)),
+    }
+  }
+
+  -- Recognize `λ _ (λ _ (Nat.succ #0))` step function shape.
+  fn is_nat_succ_ih_step(step: KExpr) -> G {
+    match load(step) {
+      KExprNode.Lam(_, body1) =>
+        match load(body1) {
+          KExprNode.Lam(_, body2) =>
+            match collect_spine(body2) {
+              (head, args) =>
+                match load(head) {
+                  KExprNode.Const(caddr, _) =>
+                    match address_eq(caddr, nat_succ_addr()) {
+                      0 => 0,
+                      _ =>
+                        match list_length(args) - 1 {
+                          0 =>
+                            match load(list_lookup(args, 0)) {
+                              KExprNode.BVar(i) => eq_zero(i),
+                              _ => 0,
+                            },
+                          _ => 0,
+                        },
+                    },
+                  _ => 0,
+                },
+            },
+          _ => 0,
+        },
+      _ => 0,
+    }
+  }
+
+  -- Fast path for `Nat.rec base (fun _ ih => succ ih) (Lit n)`. Yields
+  -- `Lit(base + n)` for literal base or the compact stuck offset
+  -- `Nat.add base (Lit n)` for symbolic base. Caller pre-whnfs step +
+  -- major (via whnf_spine).
+  fn try_nat_linear_rec(spine: List‹KExpr›, nparams: G, nmotives: G,
+                             nminors: G, major_idx: G) -> (G, KExpr) {
+    match u32_less_than(nminors, 2) {
+      1 => (0, store(KExprNode.BVar(0))),
+      _ =>
+        let raw_major = list_lookup(spine, major_idx);
+        match try_extract_nat(raw_major) {
+          (0, _) => (0, store(KExprNode.BVar(0))),
+          (1, n_klimbs) =>
+            let base_idx = nparams + nmotives;
+            let step = list_lookup(spine, base_idx + 1);
+            match is_nat_succ_ih_step(step) {
+              0 => (0, store(KExprNode.BVar(0))),
+              _ =>
+                let base = list_lookup(spine, base_idx);
+                let post = list_drop(spine, major_idx + 1);
+                match try_extract_nat(base) {
+                  (1, b_klimbs) =>
+                    (1, np_apply_spine(mk_nat_lit(klimbs_add(b_klimbs, n_klimbs)), post)),
+                  _ => mk_nat_offset_stuck(base, n_klimbs, post),
+                },
+            },
+        },
+    }
+  }
+
+  -- ============================================================================
+  -- Top-level nat dispatch: unary (succ/pred) then binop.
+  -- Caller must whnf spine args before matching Ctor / Lit / literal.
+  -- ============================================================================
+  fn try_nat_dispatch(head_addr: Addr, spine: List‹KExpr›,
+                          types: List‹KExpr›) -> (G, KExpr) {
+    let spine_len = list_length(spine);
+    let is_pred = address_eq(head_addr, nat_pred_addr());
+    let is_succ = address_eq(head_addr, nat_succ_addr());
+    match is_succ {
+      1 =>
+        match u32_less_than(spine_len, 1) {
+          1 => (0, store(KExprNode.BVar(0))),
+          _ =>
+            let a0 = list_lookup(spine, 0);
+            match try_extract_nat(a0) {
+              (1, na) =>
+                let post = list_drop(spine, 1);
+                (1, np_apply_spine(mk_nat_lit(klimbs_succ(na)), post)),
+              _ => (0, store(KExprNode.BVar(0))),
+            },
+        },
+      _ =>
+        match is_pred {
+          1 =>
+            match u32_less_than(spine_len, 1) {
+              1 => (0, store(KExprNode.BVar(0))),
+              _ =>
+                let a0 = list_lookup(spine, 0);
+                match try_extract_nat(a0) {
+                  (1, na) =>
+                    let post = list_drop(spine, 1);
+                    (1, np_apply_spine(mk_nat_lit(klimbs_normalize(klimbs_dec(na))), post)),
+                  _ => (0, store(KExprNode.BVar(0))),
+                },
+            },
+          _ => try_nat_binop_dispatch(head_addr, spine, spine_len),
+        },
+    }
+  }
+
+  -- Cold-extracted binop arm (mirror try_nat_binop_dispatch,
+  -- Primitive.lean:1671 / [[reference_aiur_hot_cold_split]]): the
+  -- binop branch (2× extract + binop-addr chain + offset dispatch +
+  -- apply_spine) is the widest arm of try_nat_dispatch, taxing
+  -- every Nat.succ/Nat.pred row when inlined. Its width now only
+  -- charges rows that actually dispatch a binop.
+  fn try_nat_binop_dispatch(head_addr: Addr, spine: List‹KExpr›,
+                                 spine_len: G) -> (G, KExpr) {
+    match u32_less_than(spine_len, 2) {
+      1 => (0, store(KExprNode.BVar(0))),
+      _ =>
+        let a0 = list_lookup(spine, 0);
+        let a1 = list_lookup(spine, 1);
+        match try_extract_nat(a0) {
+          (1, na) =>
+            match try_extract_nat(a1) {
+              (1, nb) =>
+                match try_nat_binop_addr(head_addr, na, nb) {
+                  (1, result) =>
+                    let post = list_drop(spine, 2);
+                    (1, np_apply_spine(result, post)),
+                  _ => (0, store(KExprNode.BVar(0))),
+                },
+              _ => (0, store(KExprNode.BVar(0))),
+            },
+          _ =>
+            -- Symbolic base: route to the offset-stuck check
+            -- (mirror try_nat_binop_dispatch's fall-through).
+            match try_extract_nat(a1) {
+              (1, nb) =>
+                try_nat_offset_dispatch(head_addr, a0, nb, spine),
+              _ => (0, store(KExprNode.BVar(0))),
+            },
+        },
+    }
+  }
+
+  -- Mirror try_nat_offset_dispatch (Primitive.lean:1712): a binary
+  -- Nat op whose whnf'd base is symbolic and whose second arg is
+  -- `Lit nb`. For `Nat.add` (any nb) and `Nat.div`/`Nat.mod` (nb >= 2)
+  -- the term is irreducible: return verdict 2 = "already stuck in
+  -- compact offset form" so whnf keeps it instead of delta-unfolding
+  -- into a succ^nb tower / the division algorithm. Pairs with the
+  -- offset-aware def_eq (try_def_eq_nat).
+  fn try_nat_offset_dispatch(head_addr: Addr, a0_w: KExpr, nb: KLimbs,
+                                  spine: List‹KExpr›) -> (G, KExpr) {
+    let is_add = address_eq(head_addr, nat_add_addr());
+    let is_divmod = address_eq(head_addr, nat_div_addr())
+      + address_eq(head_addr, nat_mod_addr());
+    let eligible =
+      is_add + is_divmod * (1 - klimbs_is_zero(nb))
+        * (1 - klimbs_is_zero(klimbs_normalize(klimbs_dec(nb))));
+    match eligible {
+      0 => (0, store(KExprNode.BVar(0))),
+      _ =>
+        let post = list_drop(spine, 2);
+        -- `Nat.add` keeps the canonical add-offset shape (shared with
+        -- the linear-rec collapse). Div/mod MUST keep their own head:
+        -- routing them through the add builder rewrites `x / n` into
+        -- `x + n`.
+        match is_add {
+          1 =>
+            match mk_nat_offset_stuck(a0_w, nb, post) {
+              (1, stuck) => (2, stuck),
+              _ => (0, store(KExprNode.BVar(0))),
+            },
+          _ => (2, mk_nat_binop_stuck(head_addr, a0_w, nb, post)),
+        },
+    }
+  }
+
+  -- Rebuild a stuck binary Nat op `op base (Lit n)` applied to `post`,
+  -- preserving the op's own head (div stays div, mod stays mod).
+  -- Mirror mk_nat_binop_stuck (Primitive.lean:1750), addr-first.
+  fn mk_nat_binop_stuck(op_addr: Addr, base_w: KExpr, n: KLimbs,
+                             post: List‹KExpr›) -> KExpr {
+    let op_const = store(KExprNode.Const(op_addr, store(ListNode.Nil)));
+    let stuck = store(KExprNode.App(
+      store(KExprNode.App(op_const, base_w)),
+      mk_nat_lit(n)));
+    np_apply_spine(stuck, post)
+  }
+⟧
+
+end IxVM
+
+end
diff --git a/Ix/IxVM/Kernel/Primitive.lean b/Ix/IxVM/Kernel/Primitive.lean
deleted file mode 100644
index b08aada31..000000000
--- a/Ix/IxVM/Kernel/Primitive.lean
+++ /dev/null
@@ -1,3233 +0,0 @@
-module
-public import Ix.Aiur.Meta
-public import Ix.IxVM.KernelTypes
-
-set_option maxRecDepth 8192
-
-public section
-
-namespace IxVM
-
-/-! ## Nat / String primitives
-
-Mirror: `src/ix/kernel/primitive.rs` (PrimAddrs struct + canonical
-addresses) and `src/ix/kernel/whnf.rs:500-700` (Nat-on-literals
-short-circuit dispatch).
-
-`KLimbs = List<U64>` little-endian (`KernelTypes.lean:28`). Rust
-counterpart is `num_bigint::BigUint`. Klimbs ops here mirror BigUint
-semantics on bounded inputs.
--/
-
-set_option maxRecDepth 16384 in
-def primitive := ⟦
-  -- ============================================================================
-  -- PrimIdxs: positional kernel const indices for dispatchable primitives.
-  --
-  -- Mirror: src/ix/kernel/primitive.rs::PrimAddrs (canonical addresses).
-  -- The Aiur kernel uses positional Const(idx) so we resolve addresses to
-  -- positions at ingress time. Slots:
-  --   0: nat
-  --   1: nat_zero
-  --   2: nat_succ
-  --   3: nat_pred
-  --   4: nat_add
-  --   5: nat_sub
-  --   6: nat_mul
-  --   7: nat_beq
-  --   8: nat_ble
-  --   9: str
-  -- A slot value of `0 - 1` (max G) means "primitive not present in the
-  -- current kernel const list".
-  -- ============================================================================
-
-  -- Canonical Anon-mode blake3 addresses (mirror of primitive.rs PrimAddrs).
-  fn quot_type_addr() -> Addr {
-    store([0xabu8, 0x68u8, 0x2cu8, 0x17u8, 0x78u8, 0xa1u8, 0x7bu8, 0xbeu8,
-     0xaeu8, 0x40u8, 0x32u8, 0x97u8, 0x4du8, 0xf3u8, 0x64u8, 0x47u8,
-     0xceu8, 0x8bu8, 0xfcu8, 0xabu8, 0x67u8, 0x64u8, 0xa3u8, 0x6du8,
-     0x37u8, 0x85u8, 0x66u8, 0xe3u8, 0xadu8, 0x63u8, 0xcau8, 0xb8u8])
-  }
-
-  fn quot_ctor_addr() -> Addr {
-    store([0x88u8, 0x26u8, 0x66u8, 0x77u8, 0xfeu8, 0xe7u8, 0x74u8, 0xd1u8,
-     0x09u8, 0x86u8, 0x7eu8, 0x4bu8, 0x22u8, 0x40u8, 0x28u8, 0x1au8,
-     0xa2u8, 0xeeu8, 0x12u8, 0xd9u8, 0x79u8, 0x20u8, 0xc1u8, 0x17u8,
-     0x1cu8, 0xf5u8, 0xc1u8, 0xf6u8, 0xc8u8, 0x7du8, 0xecu8, 0xf6u8])
-  }
-
-  fn quot_lift_addr() -> Addr {
-    store([0x8du8, 0xc4u8, 0xa9u8, 0x75u8, 0x27u8, 0x81u8, 0x2fu8, 0x8bu8,
-     0x78u8, 0x17u8, 0xb7u8, 0x7cu8, 0xd0u8, 0x79u8, 0xacu8, 0xe6u8,
-     0x14u8, 0x50u8, 0xaau8, 0x01u8, 0x85u8, 0xacu8, 0x58u8, 0x85u8,
-     0x66u8, 0x1eu8, 0xc2u8, 0xacu8, 0xbau8, 0x8bu8, 0x7bu8, 0xd0u8])
-  }
-
-  fn quot_ind_addr() -> Addr {
-    store([0x12u8, 0x49u8, 0x84u8, 0xbcu8, 0xb9u8, 0x52u8, 0x08u8, 0xa0u8,
-     0xf3u8, 0x0bu8, 0xb6u8, 0x9du8, 0x67u8, 0x36u8, 0xd3u8, 0xd5u8,
-     0x94u8, 0x04u8, 0xe1u8, 0x15u8, 0xe2u8, 0x20u8, 0x20u8, 0x43u8,
-     0xfdu8, 0xa3u8, 0xd3u8, 0x4eu8, 0x01u8, 0xb0u8, 0xadu8, 0x16u8])
-  }
-
-  fn bit_vec_addr() -> Addr {
-    store([0x69u8, 0x8du8, 0xd5u8, 0x93u8, 0xabu8, 0xfbu8, 0x63u8, 0xdbu8,
-     0x36u8, 0x2au8, 0xaeu8, 0xf5u8, 0x7eu8, 0x70u8, 0xa7u8, 0x93u8,
-     0x04u8, 0x4fu8, 0xb6u8, 0x57u8, 0x25u8, 0x72u8, 0x91u8, 0xeeu8,
-     0x2cu8, 0x3eu8, 0x99u8, 0x7cu8, 0xaau8, 0x42u8, 0x3eu8, 0xaeu8])
-  }
-
-  fn bit_vec_to_nat_addr() -> Addr {
-    store([0x77u8, 0xa0u8, 0x25u8, 0xc1u8, 0x9fu8, 0x8bu8, 0xe1u8, 0x31u8,
-     0xfbu8, 0x9du8, 0x5bu8, 0x0bu8, 0xecu8, 0x49u8, 0x48u8, 0x17u8,
-     0xa2u8, 0x65u8, 0x38u8, 0xb9u8, 0xa5u8, 0x50u8, 0xabu8, 0xbbu8,
-     0xceu8, 0xc8u8, 0x09u8, 0x9fu8, 0xaeu8, 0x9du8, 0xe4u8, 0xe4u8])
-  }
-
-  fn bit_vec_of_nat_addr() -> Addr {
-    store([0x90u8, 0xcau8, 0x81u8, 0x30u8, 0x73u8, 0x5cu8, 0x8du8, 0x9au8,
-     0x34u8, 0x00u8, 0x5au8, 0x89u8, 0x43u8, 0xb5u8, 0x9fu8, 0xe1u8,
-     0xdfu8, 0x18u8, 0x2eu8, 0x08u8, 0xa9u8, 0xf2u8, 0xbfu8, 0xc7u8,
-     0xdcu8, 0x83u8, 0x23u8, 0x22u8, 0x96u8, 0x59u8, 0xa5u8, 0x74u8])
-  }
-
-  fn bit_vec_ult_addr() -> Addr {
-    store([0x9fu8, 0xd8u8, 0xe7u8, 0x45u8, 0x9au8, 0x1du8, 0x2du8, 0xeeu8,
-     0xf0u8, 0x0au8, 0x49u8, 0x92u8, 0xa5u8, 0x04u8, 0x19u8, 0xbau8,
-     0xc6u8, 0x6cu8, 0x03u8, 0x08u8, 0x2bu8, 0x58u8, 0xadu8, 0xe0u8,
-     0x74u8, 0x22u8, 0x89u8, 0x6fu8, 0x13u8, 0x03u8, 0x3du8, 0x74u8])
-  }
-
-  fn decidable_decide_addr() -> Addr {
-    store([0xc5u8, 0xf7u8, 0xb1u8, 0x96u8, 0x63u8, 0xe4u8, 0x49u8, 0x9eu8,
-     0x70u8, 0xe1u8, 0xb2u8, 0x64u8, 0x51u8, 0x62u8, 0xc5u8, 0xbeu8,
-     0x15u8, 0xfau8, 0x86u8, 0x0fu8, 0x4fu8, 0x81u8, 0x57u8, 0xe3u8,
-     0x31u8, 0xaeu8, 0x54u8, 0x6cu8, 0x6fu8, 0x73u8, 0x37u8, 0x23u8])
-  }
-
-  fn lt_lt_addr() -> Addr {
-    store([0xcau8, 0xcau8, 0xeau8, 0x97u8, 0xf4u8, 0xcdu8, 0xbau8, 0x0au8,
-     0x4au8, 0x0au8, 0xf7u8, 0x10u8, 0x05u8, 0xd0u8, 0x51u8, 0x7du8,
-     0x18u8, 0x18u8, 0xabu8, 0x26u8, 0x23u8, 0xbdu8, 0x2eu8, 0xa7u8,
-     0xfau8, 0x8cu8, 0x63u8, 0x7au8, 0x0eu8, 0x3du8, 0x33u8, 0x12u8])
-  }
-
-  fn bool_type_addr() -> Addr {
-    store([0xe6u8, 0xebu8, 0xa3u8, 0xc8u8, 0xb4u8, 0xd1u8, 0x9fu8, 0x6au8,
-     0x10u8, 0x76u8, 0xb3u8, 0x9fu8, 0xa8u8, 0x9au8, 0xecu8, 0x61u8,
-     0xdcu8, 0xcbu8, 0xb9u8, 0x60u8, 0xf8u8, 0x3du8, 0x9au8, 0x62u8,
-     0xe6u8, 0xacu8, 0xf3u8, 0x5au8, 0x69u8, 0xc9u8, 0xa0u8, 0xa4u8])
-  }
-
-  fn eq_addr() -> Addr {
-    store([0x03u8, 0x6bu8, 0x63u8, 0xd5u8, 0xccu8, 0x09u8, 0x61u8, 0xe9u8,
-     0x20u8, 0xdeu8, 0xe5u8, 0x0eu8, 0x73u8, 0x64u8, 0xecu8, 0x0du8,
-     0xd3u8, 0xf9u8, 0xc3u8, 0x8au8, 0x9cu8, 0xacu8, 0xe4u8, 0x0eu8,
-     0x51u8, 0x3bu8, 0x38u8, 0x35u8, 0xdeu8, 0xc8u8, 0xe0u8, 0xc9u8])
-  }
-
-  fn eq_refl_addr() -> Addr {
-    store([0x6cu8, 0x9bu8, 0xd6u8, 0x0eu8, 0x1eu8, 0xaeu8, 0x93u8, 0x8eu8,
-     0x56u8, 0x26u8, 0xcau8, 0x23u8, 0x7du8, 0xbcu8, 0xa7u8, 0xfdu8,
-     0x95u8, 0x0fu8, 0x2eu8, 0x99u8, 0xe2u8, 0x34u8, 0xa9u8, 0x9cu8,
-     0x23u8, 0xcfu8, 0xdcu8, 0x29u8, 0x4cu8, 0xa7u8, 0xadu8, 0xceu8])
-  }
-
-  fn nat_dec_le_addr() -> Addr {
-    store([0xecu8, 0x1fu8, 0x60u8, 0xc1u8, 0xa2u8, 0x8du8, 0x48u8, 0xbcu8,
-     0x98u8, 0xfeu8, 0x3eu8, 0xf7u8, 0x2du8, 0x25u8, 0x51u8, 0x32u8,
-     0x73u8, 0x5au8, 0x50u8, 0x3cu8, 0xc3u8, 0x6eu8, 0x3fu8, 0xf0u8,
-     0xf2u8, 0x2eu8, 0x3du8, 0x48u8, 0x6eu8, 0x26u8, 0x6eu8, 0xbeu8])
-  }
-
-  fn nat_dec_eq_addr() -> Addr {
-    store([0xb4u8, 0xb2u8, 0x6cu8, 0x2eu8, 0x29u8, 0x93u8, 0x1cu8, 0x06u8,
-     0xe8u8, 0x85u8, 0x91u8, 0x46u8, 0x13u8, 0xfau8, 0xffu8, 0x58u8,
-     0x56u8, 0x13u8, 0x8eu8, 0x5cu8, 0xb0u8, 0x96u8, 0x20u8, 0xddu8,
-     0xb6u8, 0x92u8, 0x1au8, 0x34u8, 0x2du8, 0xedu8, 0x89u8, 0x57u8])
-  }
-
-  fn nat_dec_lt_addr() -> Addr {
-    store([0xc0u8, 0x13u8, 0xc1u8, 0x53u8, 0xebu8, 0xf0u8, 0x20u8, 0x28u8,
-     0xaeu8, 0xd2u8, 0x64u8, 0x33u8, 0x3cu8, 0x1eu8, 0x4cu8, 0x85u8,
-     0x01u8, 0x7du8, 0x0bu8, 0x87u8, 0x02u8, 0x5du8, 0x75u8, 0x96u8,
-     0xa9u8, 0x69u8, 0x71u8, 0xbbu8, 0x2bu8, 0x67u8, 0x92u8, 0x1du8])
-  }
-
-  fn int_dec_eq_addr() -> Addr {
-    store([0x83u8, 0xfdu8, 0xe3u8, 0x8fu8, 0xaau8, 0x11u8, 0x64u8, 0x64u8,
-     0x8eu8, 0x42u8, 0x27u8, 0x97u8, 0x5au8, 0xbfu8, 0x2eu8, 0x8cu8,
-     0x26u8, 0x0du8, 0x7du8, 0x4eu8, 0xf1u8, 0xc9u8, 0x26u8, 0x76u8,
-     0x21u8, 0x4fu8, 0xfeu8, 0x58u8, 0x26u8, 0xc2u8, 0x07u8, 0x5du8])
-  }
-
-  fn int_dec_le_addr() -> Addr {
-    store([0x38u8, 0xd6u8, 0x0fu8, 0xfau8, 0x07u8, 0xb5u8, 0x06u8, 0x78u8,
-     0xd0u8, 0xc3u8, 0xbfu8, 0x0cu8, 0x06u8, 0xf8u8, 0x6cu8, 0xd7u8,
-     0x96u8, 0x7bu8, 0x35u8, 0xe8u8, 0x7au8, 0xb0u8, 0x71u8, 0xbcu8,
-     0x55u8, 0x89u8, 0x9fu8, 0xcbu8, 0xaeu8, 0xd4u8, 0x74u8, 0x4fu8])
-  }
-
-  fn int_dec_lt_addr() -> Addr {
-    store([0x55u8, 0x68u8, 0xe7u8, 0x99u8, 0x19u8, 0x8du8, 0xadu8, 0x9fu8,
-     0xabu8, 0x0eu8, 0x78u8, 0x4bu8, 0x7au8, 0x4cu8, 0x58u8, 0x11u8,
-     0x2bu8, 0xfcu8, 0x26u8, 0x88u8, 0xaeu8, 0xceu8, 0xbeu8, 0x3cu8,
-     0x2cu8, 0x65u8, 0x63u8, 0x30u8, 0x42u8, 0x10u8, 0xf9u8, 0x56u8])
-  }
-
-  fn int_of_nat_addr() -> Addr {
-    store([0x09u8, 0xbcu8, 0x25u8, 0x31u8, 0x47u8, 0xc3u8, 0x6cu8, 0xe2u8,
-     0x2cu8, 0x8eu8, 0x0cu8, 0xcdu8, 0x43u8, 0xc7u8, 0x9bu8, 0x2cu8,
-     0xdau8, 0xe2u8, 0x20u8, 0x6eu8, 0x0du8, 0xddu8, 0x16u8, 0x8fu8,
-     0xcau8, 0x36u8, 0x09u8, 0xb2u8, 0xa5u8, 0x84u8, 0xd3u8, 0xdcu8])
-  }
-
-  fn int_neg_succ_addr() -> Addr {
-    store([0x26u8, 0x7cu8, 0x0au8, 0x9cu8, 0x92u8, 0xe7u8, 0x56u8, 0x38u8,
-     0xfcu8, 0x73u8, 0xedu8, 0x52u8, 0xa9u8, 0xf9u8, 0xc8u8, 0x16u8,
-     0x47u8, 0xeeu8, 0xecu8, 0xeeu8, 0xffu8, 0x21u8, 0x44u8, 0xc1u8,
-     0xf9u8, 0x7eu8, 0x65u8, 0xe2u8, 0xafu8, 0xf1u8, 0x49u8, 0xf1u8])
-  }
-
-  -- Address constants below registered in Rust primitive.rs but not wired
-  -- into any Aiur dispatch path. Commented out per "no unused code".
-  -- Restore + plug if a reduction/canonicalization tier needs them.
-  /-
-  fn int_addr() -> Addr {
-    store([0xa5u8, 0xcau8, 0x2eu8, 0x1du8, 0x5cu8, 0xebu8, 0x8du8, 0x43u8,
-     0x36u8, 0x7bu8, 0xc3u8, 0x4du8, 0x69u8, 0xa5u8, 0x0cu8, 0x16u8,
-     0x50u8, 0xa2u8, 0x5du8, 0xc1u8, 0x07u8, 0x80u8, 0xaau8, 0x0cu8,
-     0x37u8, 0x8cu8, 0xdfu8, 0xa9u8, 0x31u8, 0xffu8, 0x04u8, 0x24u8])
-  }
-
-  fn int_add_addr() -> Addr {
-    store([0xcau8, 0x99u8, 0x08u8, 0x4cu8, 0x9du8, 0x2fu8, 0xcbu8, 0x4cu8,
-     0x5du8, 0xd1u8, 0x39u8, 0xaeu8, 0xcau8, 0xf1u8, 0x59u8, 0xebu8,
-     0xd0u8, 0x49u8, 0x92u8, 0xd7u8, 0x62u8, 0x30u8, 0xcbu8, 0x93u8,
-     0x0fu8, 0x41u8, 0xb8u8, 0x60u8, 0x74u8, 0x68u8, 0x48u8, 0x17u8])
-  }
-
-  fn int_sub_addr() -> Addr {
-    store([0xd3u8, 0x14u8, 0x12u8, 0x31u8, 0x80u8, 0x0eu8, 0x01u8, 0x2eu8,
-     0x8du8, 0xb7u8, 0xc2u8, 0x40u8, 0xf7u8, 0x94u8, 0xe4u8, 0x92u8,
-     0x9bu8, 0xfdu8, 0x15u8, 0x6bu8, 0x38u8, 0x45u8, 0xe2u8, 0x2fu8,
-     0x1cu8, 0xf3u8, 0x1du8, 0x3fu8, 0xe3u8, 0x9au8, 0xecu8, 0xd9u8])
-  }
-
-  fn int_mul_addr() -> Addr {
-    store([0x48u8, 0x20u8, 0x64u8, 0xe3u8, 0x56u8, 0x34u8, 0xa9u8, 0x5cu8,
-     0x0fu8, 0x25u8, 0x2du8, 0xe7u8, 0x3du8, 0x68u8, 0x7cu8, 0x24u8,
-     0x76u8, 0x4eu8, 0xa4u8, 0xfau8, 0x7du8, 0xfdu8, 0x14u8, 0xcfu8,
-     0x7au8, 0xf8u8, 0xaau8, 0x75u8, 0x31u8, 0xf1u8, 0x7au8, 0x5cu8])
-  }
-
-  fn int_neg_addr() -> Addr {
-    store([0xf6u8, 0x1cu8, 0x7du8, 0x3fu8, 0xceu8, 0x59u8, 0x54u8, 0x30u8,
-     0xf8u8, 0x6fu8, 0x0cu8, 0xd5u8, 0x2du8, 0xa5u8, 0xbcu8, 0xb0u8,
-     0x0bu8, 0xf9u8, 0x10u8, 0xedu8, 0xd8u8, 0x5eu8, 0x14u8, 0xdcu8,
-     0x04u8, 0x02u8, 0x13u8, 0x0fu8, 0xccu8, 0xe3u8, 0x4eu8, 0xbdu8])
-  }
-
-  fn int_emod_addr() -> Addr {
-    store([0x25u8, 0xc2u8, 0x67u8, 0xefu8, 0x44u8, 0xf1u8, 0x50u8, 0x07u8,
-     0xf2u8, 0xd2u8, 0xe0u8, 0x81u8, 0x9bu8, 0xe6u8, 0xfbu8, 0x64u8,
-     0x90u8, 0x2cu8, 0x33u8, 0xa7u8, 0xd2u8, 0x7au8, 0x6fu8, 0x2cu8,
-     0x9du8, 0x61u8, 0x26u8, 0x38u8, 0x98u8, 0x95u8, 0x38u8, 0x04u8])
-  }
-
-  fn int_ediv_addr() -> Addr {
-    store([0x49u8, 0xb3u8, 0x4du8, 0xcbu8, 0xffu8, 0x1eu8, 0x60u8, 0x53u8,
-     0x28u8, 0x25u8, 0xffu8, 0x5au8, 0xf4u8, 0x77u8, 0xebu8, 0x5du8,
-     0xe9u8, 0x81u8, 0x0eu8, 0xe3u8, 0x8eu8, 0x0fu8, 0x7au8, 0x32u8,
-     0x01u8, 0x4du8, 0x54u8, 0xc8u8, 0xc1u8, 0xa3u8, 0xa3u8, 0xc5u8])
-  }
-
-  fn int_bmod_addr() -> Addr {
-    store([0x6au8, 0x6au8, 0xdfu8, 0x0eu8, 0x95u8, 0xb3u8, 0xa4u8, 0xceu8,
-     0x18u8, 0x33u8, 0x0eu8, 0xe2u8, 0x21u8, 0x05u8, 0x71u8, 0x2eu8,
-     0x9au8, 0x64u8, 0x0eu8, 0xe4u8, 0x31u8, 0x1bu8, 0x5du8, 0xd1u8,
-     0x02u8, 0x2au8, 0x8eu8, 0x0au8, 0x30u8, 0xcbu8, 0xa0u8, 0xafu8])
-  }
-
-  fn int_bdiv_addr() -> Addr {
-    store([0xa4u8, 0xf1u8, 0xd7u8, 0xa3u8, 0xfeu8, 0x5bu8, 0x6bu8, 0x2eu8,
-     0xf9u8, 0x52u8, 0x2fu8, 0xa5u8, 0x37u8, 0xf1u8, 0xe6u8, 0x22u8,
-     0xfbu8, 0xb8u8, 0x17u8, 0x6fu8, 0x9fu8, 0xb3u8, 0x35u8, 0x8cu8,
-     0x56u8, 0xceu8, 0xbeu8, 0x1au8, 0x37u8, 0x9bu8, 0x61u8, 0x84u8])
-  }
-
-  fn int_nat_abs_addr() -> Addr {
-    store([0x83u8, 0xe3u8, 0xceu8, 0x8au8, 0x74u8, 0x75u8, 0x20u8, 0xccu8,
-     0x24u8, 0x8au8, 0x0du8, 0xacu8, 0xf9u8, 0xbdu8, 0x13u8, 0x69u8,
-     0x46u8, 0x7eu8, 0x49u8, 0x07u8, 0xe8u8, 0xaau8, 0xaau8, 0x43u8,
-     0x3eu8, 0x1bu8, 0x43u8, 0x8eu8, 0x1cu8, 0xadu8, 0x7cu8, 0xa4u8])
-  }
-
-  fn int_pow_addr() -> Addr {
-    store([0x73u8, 0xecu8, 0xccu8, 0xfeu8, 0xabu8, 0x8au8, 0x63u8, 0xa3u8,
-     0xa0u8, 0xfau8, 0xf8u8, 0xd7u8, 0x1du8, 0xc7u8, 0x79u8, 0x95u8,
-     0xbdu8, 0xa8u8, 0x34u8, 0x18u8, 0xb1u8, 0x3cu8, 0xd3u8, 0x99u8,
-     0xb1u8, 0xfau8, 0x57u8, 0x1bu8, 0x50u8, 0xb4u8, 0x57u8, 0x5eu8])
-  }
-
-  fn bool_no_confusion_addr() -> Addr {
-    store([0xcdu8, 0x98u8, 0x3au8, 0x82u8, 0x6cu8, 0x1eu8, 0x20u8, 0xc4u8,
-     0x57u8, 0x0au8, 0xfcu8, 0xa2u8, 0x44u8, 0x91u8, 0x6cu8, 0x79u8,
-     0xe2u8, 0x0eu8, 0x81u8, 0x6fu8, 0x61u8, 0x8fu8, 0xfdu8, 0xdau8,
-     0x38u8, 0xbeu8, 0x8au8, 0x79u8, 0x07u8, 0x92u8, 0x74u8, 0xceu8])
-  }
-
-  fn char_mk_addr() -> Addr {
-    store([0x97u8, 0xafu8, 0xa5u8, 0xadu8, 0x3du8, 0x86u8, 0x89u8, 0x5eu8,
-     0x6du8, 0x15u8, 0x50u8, 0x19u8, 0xb6u8, 0x6cu8, 0x25u8, 0x6cu8,
-     0xd1u8, 0xaau8, 0x86u8, 0x2bu8, 0x4eu8, 0x3cu8, 0x89u8, 0xd8u8,
-     0xc6u8, 0x58u8, 0x0bu8, 0x61u8, 0x93u8, 0x9eu8, 0xe5u8, 0x41u8])
-  }
-
-  fn nat_bitwise_addr() -> Addr {
-    store([0xd2u8, 0x07u8, 0x5eu8, 0x32u8, 0x3bu8, 0xedu8, 0x82u8, 0xf2u8,
-     0x3eu8, 0xafu8, 0x75u8, 0xebu8, 0xc0u8, 0xfau8, 0xe4u8, 0xceu8,
-     0xb8u8, 0x07u8, 0x94u8, 0x24u8, 0x0cu8, 0x04u8, 0x6bu8, 0x90u8,
-     0xc5u8, 0x1au8, 0x94u8, 0xd0u8, 0x7fu8, 0x5eu8, 0x88u8, 0x5fu8])
-  }
-
-  fn nat_rec_addr() -> Addr {
-    store([0xb9u8, 0x75u8, 0x15u8, 0x2fu8, 0x3fu8, 0x0cu8, 0xd9u8, 0x03u8,
-     0x94u8, 0x33u8, 0xc6u8, 0x8fu8, 0x5au8, 0x5eu8, 0x54u8, 0x55u8,
-     0xf5u8, 0xcbu8, 0x5du8, 0x91u8, 0x70u8, 0x78u8, 0xbau8, 0xedu8,
-     0x01u8, 0x18u8, 0xb5u8, 0x90u8, 0x67u8, 0xa7u8, 0x4eu8, 0xa7u8])
-  }
-
-  fn nat_cases_on_addr() -> Addr {
-    store([0x19u8, 0x17u8, 0x84u8, 0x1du8, 0x20u8, 0x85u8, 0x79u8, 0x6du8,
-     0xd7u8, 0xbau8, 0x34u8, 0x6du8, 0xe9u8, 0x3au8, 0x57u8, 0x95u8,
-     0x71u8, 0xb5u8, 0x64u8, 0x1cu8, 0x33u8, 0xfcu8, 0x40u8, 0x04u8,
-     0x08u8, 0xecu8, 0x55u8, 0xb5u8, 0x77u8, 0x8au8, 0x9au8, 0x51u8])
-  }
-
-  fn list_addr() -> Addr {
-    store([0x14u8, 0x4eu8, 0x20u8, 0x7au8, 0x88u8, 0xd1u8, 0xdfu8, 0xbdu8,
-     0xe2u8, 0x2au8, 0x1bu8, 0x40u8, 0x68u8, 0x90u8, 0x33u8, 0xb3u8,
-     0xa6u8, 0x5au8, 0x65u8, 0x2cu8, 0x8fu8, 0x75u8, 0x00u8, 0xb9u8,
-     0xbeu8, 0x3cu8, 0xb7u8, 0xf6u8, 0x63u8, 0x66u8, 0xe0u8, 0xfeu8])
-  }
-
-  fn string_addr() -> Addr {
-    store([0x7au8, 0xb2u8, 0xd5u8, 0x2au8, 0xc5u8, 0x2fu8, 0xd1u8, 0xf5u8,
-     0x18u8, 0x09u8, 0xb7u8, 0x18u8, 0xe5u8, 0x3cu8, 0xd0u8, 0x58u8,
-     0xacu8, 0x4bu8, 0x50u8, 0xd6u8, 0x51u8, 0x50u8, 0xe7u8, 0x8au8,
-     0xe6u8, 0x19u8, 0x13u8, 0x9cu8, 0xcfu8, 0x13u8, 0xc8u8, 0xfdu8])
-  }
-
-  fn string_mk_addr() -> Addr {
-    store([0x96u8, 0x71u8, 0xfdu8, 0x4fu8, 0xcfu8, 0xbcu8, 0x06u8, 0x1cu8,
-     0x93u8, 0xc2u8, 0x82u8, 0x48u8, 0x64u8, 0xcfu8, 0x03u8, 0x12u8,
-     0x4fu8, 0xfeu8, 0xe7u8, 0xccu8, 0x22u8, 0x30u8, 0x8du8, 0xe1u8,
-     0x2au8, 0x7cu8, 0x82u8, 0x64u8, 0x73u8, 0xe4u8, 0x99u8, 0x06u8])
-  }
-
-  fn of_nat_of_nat_addr() -> Addr {
-    store([0x5au8, 0x72u8, 0x92u8, 0xadu8, 0x75u8, 0x6eu8, 0xe1u8, 0xf2u8,
-     0xdfu8, 0x4bu8, 0x92u8, 0xf1u8, 0x8au8, 0x27u8, 0x57u8, 0x4au8,
-     0x47u8, 0xcbu8, 0xbcu8, 0xf7u8, 0x09u8, 0x4fu8, 0x98u8, 0xabu8,
-     0x28u8, 0x65u8, 0xf9u8, 0x2eu8, 0xb2u8, 0x23u8, 0x42u8, 0xd7u8])
-  }
-
-  fn eager_reduce_addr() -> Addr {
-    -- Aiur is permanently eager (no fvars, no fuel); this address is
-    -- registered for parity with Rust but never matched.
-    store([0x00u8; 32])
-  }
-
-  fn pprod_addr() -> Addr {
-    store([0x81u8, 0xa4u8, 0x22u8, 0xa4u8, 0x2bu8, 0x2cu8, 0xb6u8, 0x56u8,
-     0xb9u8, 0xa4u8, 0x7eu8, 0x61u8, 0xa4u8, 0x42u8, 0x2fu8, 0x89u8,
-     0xcdu8, 0xb0u8, 0xa0u8, 0xc1u8, 0x66u8, 0x03u8, 0x5du8, 0x47u8,
-     0xbfu8, 0x5eu8, 0x2cu8, 0x2au8, 0xf0u8, 0x21u8, 0x75u8, 0xfau8])
-  }
-
-  fn pprod_mk_addr() -> Addr {
-    store([0xc9u8, 0xc5u8, 0x84u8, 0xdau8, 0x78u8, 0x2cu8, 0xdcu8, 0x45u8,
-     0x33u8, 0x06u8, 0xbeu8, 0x9au8, 0x64u8, 0x32u8, 0x44u8, 0xfau8,
-     0x0bu8, 0xcbu8, 0xfcu8, 0x3bu8, 0x5du8, 0xbcu8, 0xbau8, 0xfeu8,
-     0x3fu8, 0x6bu8, 0x9du8, 0x65u8, 0xdfu8, 0x03u8, 0x1fu8, 0xedu8])
-  }
-  -/
-
-  fn fin_addr() -> Addr {
-    store([0x74u8, 0x59u8, 0x36u8, 0xfcu8, 0xb9u8, 0xd8u8, 0x6cu8, 0x44u8,
-     0x57u8, 0xf0u8, 0xfdu8, 0x1eu8, 0x53u8, 0x7eu8, 0x67u8, 0x07u8,
-     0x7fu8, 0x46u8, 0xf7u8, 0x84u8, 0x11u8, 0x08u8, 0x41u8, 0x9du8,
-     0xacu8, 0x79u8, 0x84u8, 0x00u8, 0x8bu8, 0x56u8, 0x5bu8, 0x97u8])
-  }
-
-  fn decidable_rec_addr() -> Addr {
-    store([0xabu8, 0x37u8, 0x76u8, 0x98u8, 0x57u8, 0x43u8, 0xafu8, 0x13u8,
-     0xa9u8, 0xcbu8, 0x1au8, 0x7du8, 0x2fu8, 0x84u8, 0x96u8, 0x99u8,
-     0x78u8, 0x92u8, 0xe1u8, 0x79u8, 0x83u8, 0xd1u8, 0x4bu8, 0xe5u8,
-     0x27u8, 0x0au8, 0x71u8, 0x65u8, 0x70u8, 0xb3u8, 0x57u8, 0x19u8])
-  }
-
-  fn decidable_is_true_addr() -> Addr {
-    store([0x0fu8, 0x9eu8, 0xe8u8, 0xd9u8, 0x03u8, 0x3du8, 0x8fu8, 0x7bu8,
-     0x85u8, 0x2fu8, 0x5bu8, 0x71u8, 0x52u8, 0xfdu8, 0x12u8, 0x4fu8,
-     0x7du8, 0x41u8, 0x19u8, 0x30u8, 0xc9u8, 0x92u8, 0xe0u8, 0xf4u8,
-     0x57u8, 0xf8u8, 0x10u8, 0x4bu8, 0x60u8, 0xa9u8, 0x83u8, 0x81u8])
-  }
-
-  fn decidable_is_false_addr() -> Addr {
-    store([0x04u8, 0x71u8, 0xe4u8, 0x71u8, 0x58u8, 0xb2u8, 0xaeu8, 0x18u8,
-     0xd3u8, 0xc0u8, 0x8du8, 0xd5u8, 0xc7u8, 0x7au8, 0xaeu8, 0x23u8,
-     0xe6u8, 0x2du8, 0x7bu8, 0xbcu8, 0x1eu8, 0x61u8, 0x11u8, 0x6bu8,
-     0xc2u8, 0x81u8, 0x3bu8, 0x13u8, 0x06u8, 0xbcu8, 0x57u8, 0x95u8])
-  }
-
-  fn nat_le_of_ble_eq_true_addr() -> Addr {
-    store([0x21u8, 0xe0u8, 0xe0u8, 0x78u8, 0x3bu8, 0x76u8, 0x17u8, 0xb0u8,
-     0xccu8, 0x4eu8, 0xffu8, 0x4du8, 0x1fu8, 0xabu8, 0x7cu8, 0xffu8,
-     0xefu8, 0xe0u8, 0x1cu8, 0xd4u8, 0x3du8, 0xa7u8, 0x7eu8, 0x2fu8,
-     0x98u8, 0xd1u8, 0x50u8, 0x94u8, 0xa0u8, 0xd8u8, 0xf0u8, 0x86u8])
-  }
-
-  fn nat_not_le_of_not_ble_eq_true_addr() -> Addr {
-    store([0x01u8, 0x83u8, 0x59u8, 0x5bu8, 0x83u8, 0x7bu8, 0x9bu8, 0x84u8,
-     0xdau8, 0x5fu8, 0x00u8, 0x4bu8, 0x8au8, 0xc4u8, 0xa4u8, 0xbbu8,
-     0xd3u8, 0xbcu8, 0x06u8, 0x28u8, 0xb9u8, 0x9cu8, 0x8du8, 0x55u8,
-     0x0eu8, 0xb3u8, 0x51u8, 0xf7u8, 0x4cu8, 0xe1u8, 0x6du8, 0x48u8])
-  }
-
-  fn nat_eq_of_beq_eq_true_addr() -> Addr {
-    store([0x9cu8, 0xe6u8, 0xe3u8, 0x22u8, 0xf1u8, 0x94u8, 0x81u8, 0xf2u8,
-     0x1cu8, 0xf4u8, 0xc4u8, 0x8fu8, 0x88u8, 0x78u8, 0x98u8, 0x76u8,
-     0xb6u8, 0x9bu8, 0x8au8, 0x9bu8, 0x15u8, 0x20u8, 0x43u8, 0x9cu8,
-     0x10u8, 0x1du8, 0x98u8, 0x3fu8, 0x96u8, 0xeau8, 0x60u8, 0xb7u8])
-  }
-
-  fn nat_ne_of_beq_eq_false_addr() -> Addr {
-    store([0x3cu8, 0xf5u8, 0x4du8, 0x33u8, 0x38u8, 0x21u8, 0xddu8, 0x37u8,
-     0x68u8, 0x3au8, 0x0bu8, 0xf3u8, 0x87u8, 0x39u8, 0xe6u8, 0x87u8,
-     0x61u8, 0x0au8, 0x19u8, 0x91u8, 0x75u8, 0x92u8, 0x20u8, 0xb7u8,
-     0x7eu8, 0xdeu8, 0xc3u8, 0x38u8, 0xbau8, 0x3cu8, 0xfbu8, 0xc8u8])
-  }
-
-  fn reduce_bool_addr() -> Addr {
-    store([0x1cu8, 0x17u8, 0x00u8, 0x98u8, 0xe2u8, 0x31u8, 0x43u8, 0xfdu8,
-     0x8fu8, 0xd6u8, 0x17u8, 0x2cu8, 0xefu8, 0xd2u8, 0xecu8, 0xeeu8,
-     0x30u8, 0x50u8, 0x72u8, 0xd2u8, 0x99u8, 0x11u8, 0x13u8, 0xcfu8,
-     0xc4u8, 0xd5u8, 0x28u8, 0x40u8, 0xa5u8, 0xa9u8, 0xfau8, 0x78u8])
-  }
-
-  fn reduce_nat_addr() -> Addr {
-    store([0x16u8, 0x85u8, 0x30u8, 0x76u8, 0xb0u8, 0xd9u8, 0x6du8, 0x35u8,
-     0x6du8, 0x85u8, 0x48u8, 0x5cu8, 0x56u8, 0xf3u8, 0x39u8, 0x80u8,
-     0x14u8, 0xb6u8, 0xa0u8, 0xf2u8, 0xeeu8, 0x72u8, 0xabu8, 0x16u8,
-     0x28u8, 0x4au8, 0x38u8, 0x1du8, 0x9cu8, 0x28u8, 0xe5u8, 0x60u8])
-  }
-
-  fn system_platform_num_bits_addr() -> Addr {
-    store([0xcfu8, 0x86u8, 0x26u8, 0x35u8, 0x21u8, 0xd3u8, 0x45u8, 0xc3u8,
-     0x90u8, 0x76u8, 0x47u8, 0x3eu8, 0xcdu8, 0xb9u8, 0xf6u8, 0xfdu8,
-     0x41u8, 0x1bu8, 0x5bu8, 0x50u8, 0x3bu8, 0xceu8, 0x83u8, 0xe2u8,
-     0x31u8, 0x8bu8, 0xa3u8, 0xfbu8, 0x6fu8, 0x23u8, 0x76u8, 0xd8u8])
-  }
-
-  fn system_platform_get_num_bits_addr() -> Addr {
-    store([0xf5u8, 0xd2u8, 0x56u8, 0xc1u8, 0xddu8, 0x79u8, 0x4du8, 0x02u8,
-     0xcfu8, 0xdfu8, 0x17u8, 0x62u8, 0xc9u8, 0xe4u8, 0x1bu8, 0x13u8,
-     0xabu8, 0xe5u8, 0xbdu8, 0xddu8, 0xe1u8, 0x2du8, 0x92u8, 0x9du8,
-     0x02u8, 0xadu8, 0xa3u8, 0x7eu8, 0x4fu8, 0x40u8, 0xe8u8, 0x5fu8])
-  }
-
-  fn subtype_val_addr() -> Addr {
-    store([0x0bu8, 0x59u8, 0x58u8, 0xa3u8, 0xc8u8, 0x22u8, 0xc9u8, 0x9eu8,
-     0x86u8, 0x43u8, 0xa2u8, 0x7fu8, 0x0bu8, 0x92u8, 0x8du8, 0xfbu8,
-     0x82u8, 0xc4u8, 0x54u8, 0x47u8, 0xbeu8, 0xe0u8, 0x35u8, 0x3cu8,
-     0x20u8, 0x0au8, 0xd1u8, 0xb7u8, 0xd0u8, 0xe4u8, 0x60u8, 0x92u8])
-  }
-
-  fn punit_size_of_1_addr() -> Addr {
-    store([0x7bu8, 0xd8u8, 0xe1u8, 0x9fu8, 0x47u8, 0xf6u8, 0xeau8, 0xe6u8,
-     0x20u8, 0xa5u8, 0xc3u8, 0x9fu8, 0x24u8, 0x3cu8, 0xe4u8, 0x15u8,
-     0xddu8, 0x6au8, 0x77u8, 0xf0u8, 0x95u8, 0x90u8, 0xf4u8, 0xc2u8,
-     0x27u8, 0xceu8, 0xf3u8, 0x63u8, 0x00u8, 0x7fu8, 0x40u8, 0x12u8])
-  }
-
-  fn size_of_size_of_addr() -> Addr {
-    store([0x38u8, 0x97u8, 0x15u8, 0xf9u8, 0x1eu8, 0x66u8, 0x68u8, 0x3du8,
-     0xc7u8, 0x10u8, 0x8cu8, 0xcdu8, 0x85u8, 0x3eu8, 0xfcu8, 0xe9u8,
-     0x29u8, 0x49u8, 0x51u8, 0x2fu8, 0xa6u8, 0x59u8, 0xadu8, 0x3cu8,
-     0x19u8, 0x02u8, 0xe7u8, 0x54u8, 0x69u8, 0x29u8, 0x19u8, 0xcdu8])
-  }
-
-  fn punit_addr() -> Addr {
-    store([0x2du8, 0xfcu8, 0x16u8, 0xafu8, 0x01u8, 0xb8u8, 0x2bu8, 0x3bu8,
-     0x91u8, 0xc2u8, 0xffu8, 0x70u8, 0x44u8, 0x09u8, 0xd7u8, 0x62u8,
-     0x36u8, 0xa8u8, 0x3fu8, 0x95u8, 0x6cu8, 0x0cu8, 0x6eu8, 0x66u8,
-     0x59u8, 0xa6u8, 0x4fu8, 0xe2u8, 0x1du8, 0x76u8, 0x69u8, 0x5bu8])
-  }
-
-  fn unit_addr() -> Addr {
-    store([0x92u8, 0x32u8, 0x49u8, 0x86u8, 0x67u8, 0xf7u8, 0x65u8, 0xf4u8,
-     0x37u8, 0xdeu8, 0xdau8, 0xacu8, 0x82u8, 0x8eu8, 0x55u8, 0x5fu8,
-     0x6cu8, 0xc6u8, 0x7au8, 0x20u8, 0xe6u8, 0xdbu8, 0x28u8, 0xf6u8,
-     0x14u8, 0xfdu8, 0xf3u8, 0xc2u8, 0x62u8, 0x71u8, 0x0fu8, 0xebu8])
-  }
-
-  fn nat_addr() -> Addr {
-    store([0x39u8, 0x8au8, 0x77u8, 0x06u8, 0xcfu8, 0x13u8, 0xf2u8, 0x23u8,
-     0x99u8, 0x2du8, 0x17u8, 0x3du8, 0xceu8, 0x07u8, 0x94u8, 0x68u8,
-     0x57u8, 0x24u8, 0x0fu8, 0x49u8, 0xafu8, 0xccu8, 0x74u8, 0x37u8,
-     0x23u8, 0xe8u8, 0x39u8, 0xf8u8, 0xf3u8, 0xf2u8, 0xb6u8, 0x31u8])
-  }
-
-  fn nat_zero_addr() -> Addr {
-    store([0xd3u8, 0x97u8, 0x37u8, 0x01u8, 0x57u8, 0xfbu8, 0x9au8, 0xe2u8,
-     0xc6u8, 0xe1u8, 0xedu8, 0xa7u8, 0x9fu8, 0xebu8, 0x10u8, 0xbfu8,
-     0x49u8, 0x74u8, 0x01u8, 0x74u8, 0x1au8, 0xbau8, 0x78u8, 0x8fu8,
-     0xabu8, 0x72u8, 0x6cu8, 0xfau8, 0x4cu8, 0x46u8, 0x7du8, 0xb6u8])
-  }
-
-  fn nat_succ_addr() -> Addr {
-    store([0xdeu8, 0xf5u8, 0x2du8, 0x1du8, 0xadu8, 0x5fu8, 0x10u8, 0xcfu8,
-     0x98u8, 0x93u8, 0xc9u8, 0x45u8, 0xe1u8, 0x69u8, 0x71u8, 0x8du8,
-     0x62u8, 0xb1u8, 0x5eu8, 0x2du8, 0xd2u8, 0xc9u8, 0x06u8, 0x6eu8,
-     0x59u8, 0x7bu8, 0x9du8, 0x45u8, 0x70u8, 0xbau8, 0x05u8, 0x6eu8])
-  }
-
-  fn nat_pred_addr() -> Addr {
-    store([0x91u8, 0x4fu8, 0x9cu8, 0x01u8, 0x88u8, 0x48u8, 0x53u8, 0x65u8,
-     0x2eu8, 0x92u8, 0x24u8, 0xdcu8, 0x51u8, 0x1fu8, 0x86u8, 0x7du8,
-     0x54u8, 0x08u8, 0x51u8, 0x7fu8, 0x3bu8, 0xebu8, 0x31u8, 0x92u8,
-     0xfcu8, 0x44u8, 0x77u8, 0xe0u8, 0xe9u8, 0x59u8, 0x4cu8, 0x88u8])
-  }
-
-  fn nat_add_addr() -> Addr {
-    store([0xd6u8, 0xf6u8, 0x2au8, 0x97u8, 0x79u8, 0x10u8, 0x8fu8, 0x9fu8,
-     0xb6u8, 0xb6u8, 0x6bu8, 0x31u8, 0xccu8, 0x94u8, 0xc3u8, 0xd8u8,
-     0x4cu8, 0xa7u8, 0x2du8, 0x8bu8, 0xeau8, 0x18u8, 0x5eu8, 0x13u8,
-     0x13u8, 0x7cu8, 0x50u8, 0xc7u8, 0xefu8, 0x84u8, 0xc9u8, 0x69u8])
-  }
-
-  fn nat_sub_addr() -> Addr {
-    store([0xfdu8, 0xbdu8, 0x5fu8, 0xefu8, 0x40u8, 0x14u8, 0x9cu8, 0x85u8,
-     0x33u8, 0x3cu8, 0x6fu8, 0x3cu8, 0xceu8, 0xbbu8, 0x4bu8, 0xe7u8,
-     0x41u8, 0x27u8, 0x0du8, 0x20u8, 0x66u8, 0x33u8, 0x6cu8, 0xb2u8,
-     0xeeu8, 0xf8u8, 0x76u8, 0x23u8, 0x74u8, 0x4bu8, 0x72u8, 0xb0u8])
-  }
-
-  fn nat_mul_addr() -> Addr {
-    store([0x66u8, 0x49u8, 0x66u8, 0x56u8, 0x07u8, 0xb0u8, 0x75u8, 0x0cu8,
-     0x2cu8, 0xa7u8, 0x3fu8, 0x45u8, 0xdeu8, 0x60u8, 0x0fu8, 0x21u8,
-     0xcbu8, 0x67u8, 0x03u8, 0x98u8, 0x50u8, 0x48u8, 0x65u8, 0xbbu8,
-     0x97u8, 0x97u8, 0x24u8, 0x38u8, 0x01u8, 0x4fu8, 0x96u8, 0xd9u8])
-  }
-
-  fn nat_pow_addr() -> Addr {
-    store([0x33u8, 0xc6u8, 0x04u8, 0x45u8, 0x1du8, 0x01u8, 0xcbu8, 0x19u8,
-     0xa4u8, 0x33u8, 0x66u8, 0x82u8, 0x46u8, 0xb9u8, 0x8fu8, 0x6eu8,
-     0x87u8, 0x4bu8, 0xd6u8, 0x30u8, 0xb7u8, 0x8au8, 0x79u8, 0x1du8,
-     0x7au8, 0x37u8, 0x3au8, 0x97u8, 0x98u8, 0x49u8, 0xa1u8, 0xcfu8])
-  }
-
-  fn nat_gcd_addr() -> Addr {
-    store([0x3bu8, 0xe4u8, 0x83u8, 0x57u8, 0xaeu8, 0x17u8, 0xf7u8, 0x4du8,
-     0x4du8, 0xf2u8, 0x7du8, 0x69u8, 0x7au8, 0xedu8, 0x3fu8, 0x47u8,
-     0xc1u8, 0x30u8, 0x79u8, 0x41u8, 0xf4u8, 0x1au8, 0xffu8, 0xcfu8,
-     0x74u8, 0xdau8, 0x5fu8, 0x66u8, 0xd5u8, 0x11u8, 0xa7u8, 0x97u8])
-  }
-
-  fn nat_mod_addr() -> Addr {
-    store([0x51u8, 0x79u8, 0x63u8, 0x8bu8, 0x82u8, 0xccu8, 0x83u8, 0x37u8,
-     0x91u8, 0x4au8, 0x7bu8, 0xcau8, 0xadu8, 0x85u8, 0x8cu8, 0x85u8,
-     0x88u8, 0x88u8, 0x44u8, 0xe9u8, 0xa2u8, 0x92u8, 0x43u8, 0x0cu8,
-     0xacu8, 0x51u8, 0xe5u8, 0xeau8, 0xdcu8, 0x41u8, 0xa1u8, 0xafu8])
-  }
-
-  fn nat_div_addr() -> Addr {
-    store([0x89u8, 0xdeu8, 0xcau8, 0x86u8, 0xddu8, 0x8fu8, 0x00u8, 0x66u8,
-     0xa5u8, 0x06u8, 0x4fu8, 0xdbu8, 0x19u8, 0xa2u8, 0xc6u8, 0x89u8,
-     0x7au8, 0x3au8, 0x98u8, 0x67u8, 0xcau8, 0xadu8, 0xc0u8, 0x4fu8,
-     0x77u8, 0x8du8, 0x5cu8, 0x5cu8, 0xd0u8, 0x22u8, 0x53u8, 0x62u8])
-  }
-
-  fn nat_land_addr() -> Addr {
-    store([0x81u8, 0x8au8, 0xbbu8, 0x33u8, 0x11u8, 0x50u8, 0x40u8, 0x0du8,
-     0x10u8, 0xb3u8, 0x4fu8, 0xaeu8, 0x4du8, 0xfbu8, 0x94u8, 0x26u8,
-     0x74u8, 0x1cu8, 0x46u8, 0x07u8, 0xbau8, 0xeeu8, 0xd8u8, 0xd9u8,
-     0x62u8, 0x71u8, 0xbau8, 0x16u8, 0x59u8, 0x05u8, 0x8eu8, 0xf8u8])
-  }
-
-  fn nat_lor_addr() -> Addr {
-    store([0x9bu8, 0x76u8, 0xf3u8, 0x2bu8, 0xbbu8, 0x1du8, 0xbdu8, 0xf4u8,
-     0xffu8, 0x68u8, 0xe0u8, 0x22u8, 0x12u8, 0x25u8, 0x01u8, 0x5du8,
-     0xf0u8, 0xcau8, 0x2du8, 0x2au8, 0x60u8, 0x23u8, 0xc1u8, 0xa8u8,
-     0x13u8, 0x06u8, 0xd4u8, 0x02u8, 0x0du8, 0x4eu8, 0xf3u8, 0x97u8])
-  }
-
-  fn nat_xor_addr() -> Addr {
-    store([0x97u8, 0xe3u8, 0x25u8, 0xa9u8, 0x6au8, 0x6au8, 0x18u8, 0x27u8,
-     0x19u8, 0x4eu8, 0xebu8, 0x7du8, 0x2au8, 0xa0u8, 0xd9u8, 0x19u8,
-     0x21u8, 0x07u8, 0x3au8, 0xefu8, 0x9cu8, 0x2du8, 0x33u8, 0x3cu8,
-     0x24u8, 0x61u8, 0x3eu8, 0x9au8, 0xc9u8, 0x56u8, 0xedu8, 0x29u8])
-  }
-
-  fn nat_shift_left_addr() -> Addr {
-    store([0xdcu8, 0x81u8, 0xe4u8, 0x1cu8, 0xadu8, 0x11u8, 0x90u8, 0x37u8,
-     0x7du8, 0xbeu8, 0x60u8, 0x4bu8, 0xfcu8, 0x3au8, 0xfeu8, 0x65u8,
-     0x8au8, 0x41u8, 0x3bu8, 0x9au8, 0x2du8, 0xcfu8, 0xbcu8, 0xabu8,
-     0x79u8, 0xfau8, 0xd7u8, 0xb7u8, 0xa5u8, 0xcdu8, 0xd9u8, 0x54u8])
-  }
-
-  fn nat_shift_right_addr() -> Addr {
-    store([0x6du8, 0xb4u8, 0x93u8, 0x04u8, 0xbfu8, 0x0fu8, 0x5au8, 0xcbu8,
-     0xfdu8, 0x1du8, 0x9du8, 0x9au8, 0x0cu8, 0x1bu8, 0x7au8, 0xe2u8,
-     0x0eu8, 0xf9u8, 0x9du8, 0x07u8, 0x37u8, 0x88u8, 0x70u8, 0x56u8,
-     0x12u8, 0x9fu8, 0x5bu8, 0x5cu8, 0xb5u8, 0xa9u8, 0xbau8, 0x8au8])
-  }
-
-  fn nat_beq_addr() -> Addr {
-    store([0xa3u8, 0x4au8, 0xb2u8, 0xdau8, 0xbau8, 0x34u8, 0x83u8, 0x9eu8,
-     0x85u8, 0x1fu8, 0xa3u8, 0x67u8, 0x51u8, 0x24u8, 0x56u8, 0x6fu8,
-     0x9fu8, 0x4du8, 0xcdu8, 0xe5u8, 0x97u8, 0x34u8, 0x9eu8, 0xcdu8,
-     0x54u8, 0xaeu8, 0x32u8, 0xf8u8, 0x42u8, 0x4eu8, 0x44u8, 0xb8u8])
-  }
-
-  fn nat_ble_addr() -> Addr {
-    store([0xdeu8, 0x0bu8, 0xefu8, 0xa8u8, 0x4fu8, 0xaau8, 0x22u8, 0xd1u8,
-     0x39u8, 0x43u8, 0x79u8, 0xa0u8, 0xbau8, 0x67u8, 0x29u8, 0x6eu8,
-     0x11u8, 0x66u8, 0x60u8, 0xf7u8, 0x81u8, 0xb4u8, 0xebu8, 0x63u8,
-     0x9du8, 0xbbu8, 0xabu8, 0xa2u8, 0x00u8, 0xefu8, 0x2bu8, 0xf8u8])
-  }
-
-  fn str_addr() -> Addr {
-    store([0x7au8, 0xb2u8, 0xd5u8, 0x2au8, 0xc5u8, 0x2fu8, 0xd1u8, 0xf5u8,
-     0x18u8, 0x09u8, 0xb7u8, 0x18u8, 0xe5u8, 0x3cu8, 0xd0u8, 0x58u8,
-     0xacu8, 0x4bu8, 0x50u8, 0xd6u8, 0x51u8, 0x50u8, 0xe7u8, 0x8au8,
-     0xe6u8, 0x19u8, 0x13u8, 0x9cu8, 0xcfu8, 0x13u8, 0xc8u8, 0xfdu8])
-  }
-
-  fn string_utf8_byte_size_addr() -> Addr {
-    store([0xdeu8, 0xf4u8, 0x43u8, 0x3du8, 0x95u8, 0x47u8, 0xb5u8, 0x31u8,
-     0x75u8, 0xe2u8, 0x4au8, 0x3au8, 0xc1u8, 0x82u8, 0xc8u8, 0x8bu8,
-     0x07u8, 0x2au8, 0xf0u8, 0xd4u8, 0xadu8, 0x33u8, 0xfdu8, 0x04u8,
-     0xecu8, 0x4cu8, 0xf2u8, 0xbau8, 0x3du8, 0x95u8, 0xeau8, 0x93u8])
-  }
-
-  fn string_back_addr() -> Addr {
-    store([0xe9u8, 0x5cu8, 0x8du8, 0x87u8, 0x6eu8, 0x7cu8, 0xcfu8, 0x78u8,
-     0x04u8, 0x18u8, 0x61u8, 0x5eu8, 0x33u8, 0xb7u8, 0x47u8, 0xa2u8,
-     0x45u8, 0xd9u8, 0x4fu8, 0xacu8, 0xd7u8, 0x56u8, 0x7fu8, 0xecu8,
-     0xbeu8, 0x7au8, 0xe7u8, 0x3au8, 0x5au8, 0xc0u8, 0x92u8, 0x06u8])
-  }
-
-  fn string_legacy_back_addr() -> Addr {
-    store([0x6bu8, 0xb6u8, 0x16u8, 0x2au8, 0xacu8, 0x7du8, 0x6au8, 0x01u8,
-     0xb6u8, 0xecu8, 0x05u8, 0x58u8, 0x06u8, 0x64u8, 0xe8u8, 0xa7u8,
-     0xf0u8, 0xd4u8, 0xb0u8, 0xecu8, 0x1fu8, 0xc5u8, 0xafu8, 0xaau8,
-     0xe6u8, 0x60u8, 0x18u8, 0xe9u8, 0xa1u8, 0x93u8, 0x6du8, 0xacu8])
-  }
-
-  fn string_to_byte_array_addr() -> Addr {
-    store([0xedu8, 0x43u8, 0xc7u8, 0x7eu8, 0x55u8, 0x55u8, 0x93u8, 0xb6u8,
-     0xcdu8, 0x0du8, 0x4bu8, 0xfbu8, 0xc4u8, 0x27u8, 0x3bu8, 0xa1u8,
-     0x22u8, 0xe1u8, 0xc0u8, 0xcdu8, 0xf1u8, 0x09u8, 0x05u8, 0x71u8,
-     0x61u8, 0x2au8, 0x95u8, 0x2fu8, 0x94u8, 0x1eu8, 0xadu8, 0xb1u8])
-  }
-
-  fn byte_array_empty_addr() -> Addr {
-    store([0x7cu8, 0xfbu8, 0xa8u8, 0xfau8, 0x95u8, 0x84u8, 0x7cu8, 0x21u8,
-     0x3au8, 0xa4u8, 0x06u8, 0x61u8, 0x10u8, 0xbau8, 0x01u8, 0xa9u8,
-     0x7fu8, 0xb5u8, 0x97u8, 0xdau8, 0xf2u8, 0x9fu8, 0x5cu8, 0x07u8,
-     0xf7u8, 0x23u8, 0x66u8, 0x07u8, 0x2fu8, 0x25u8, 0x07u8, 0x44u8])
-  }
-
-  fn char_of_nat_addr() -> Addr {
-    store([0x1au8, 0x4cu8, 0x66u8, 0xf7u8, 0x67u8, 0x60u8, 0xf5u8, 0xefu8,
-     0x38u8, 0x6du8, 0xe0u8, 0x89u8, 0x68u8, 0x2au8, 0x55u8, 0xb7u8,
-     0x52u8, 0x13u8, 0x1eu8, 0x14u8, 0xa0u8, 0x85u8, 0x57u8, 0xc4u8,
-     0x46u8, 0x5eu8, 0xd1u8, 0x7fu8, 0xe0u8, 0xc4u8, 0xdcu8, 0x86u8])
-  }
-
-  fn char_type_addr() -> Addr {
-    store([0x29u8, 0xddu8, 0x2du8, 0x19u8, 0x86u8, 0xa5u8, 0x25u8, 0xbdu8,
-     0xdeu8, 0x49u8, 0xb4u8, 0xadu8, 0x2du8, 0xefu8, 0xc3u8, 0x49u8,
-     0xceu8, 0xc7u8, 0x1du8, 0x04u8, 0x84u8, 0xcdu8, 0x13u8, 0xf2u8,
-     0xdau8, 0x92u8, 0xf1u8, 0xfcu8, 0xe8u8, 0x9au8, 0x4cu8, 0x79u8])
-  }
-
-  fn string_of_list_addr() -> Addr {
-    store([0x96u8, 0x71u8, 0xfdu8, 0x4fu8, 0xcfu8, 0xbcu8, 0x06u8, 0x1cu8,
-     0x93u8, 0xc2u8, 0x82u8, 0x48u8, 0x64u8, 0xcfu8, 0x03u8, 0x12u8,
-     0x4fu8, 0xfeu8, 0xe7u8, 0xccu8, 0x22u8, 0x30u8, 0x8du8, 0xe1u8,
-     0x2au8, 0x7cu8, 0x82u8, 0x64u8, 0x73u8, 0xe4u8, 0x99u8, 0x06u8])
-  }
-
-  -- Native string-value fast paths (mirror crates/kernel/src/primitive.rs
-  -- `string_append` / `string_dec_eq`): literal append and literal
-  -- decidable equality reduce natively in whnf, keeping evaluator-grade
-  -- string values out of the structural ByteArray/UTF-8 model.
-  fn string_append_addr() -> Addr {
-    store([0x59u8, 0x4fu8, 0xb1u8, 0xeeu8, 0xdeu8, 0xc7u8, 0xc9u8, 0x39u8,
-     0xccu8, 0x87u8, 0x2bu8, 0x6cu8, 0x04u8, 0xccu8, 0x3bu8, 0x3eu8,
-     0x0au8, 0x97u8, 0x64u8, 0xfau8, 0xbeu8, 0xc3u8, 0xe6u8, 0x02u8,
-     0xadu8, 0x92u8, 0x14u8, 0xd0u8, 0xe6u8, 0x37u8, 0xd3u8, 0x0fu8])
-  }
-
-  fn string_dec_eq_addr() -> Addr {
-    store([0x82u8, 0xe5u8, 0x56u8, 0x8du8, 0x88u8, 0xe2u8, 0x4fu8, 0x24u8,
-     0xd5u8, 0xbeu8, 0xfau8, 0xc3u8, 0x0cu8, 0xe9u8, 0x15u8, 0x01u8,
-     0x0eu8, 0x92u8, 0x59u8, 0x6fu8, 0x55u8, 0xa8u8, 0x22u8, 0xe2u8,
-     0x9fu8, 0x48u8, 0x76u8, 0xeau8, 0x3au8, 0x57u8, 0x93u8, 0x94u8])
-  }
-
-  fn list_nil_addr() -> Addr {
-    store([0x25u8, 0x8au8, 0x73u8, 0x64u8, 0xb8u8, 0x7cu8, 0x99u8, 0xfeu8,
-     0x9fu8, 0x83u8, 0xe0u8, 0x5eu8, 0x0du8, 0x05u8, 0xc9u8, 0x35u8,
-     0x60u8, 0x9au8, 0x0du8, 0xc5u8, 0xdfu8, 0x8du8, 0x77u8, 0x93u8,
-     0x91u8, 0x30u8, 0xefu8, 0xe5u8, 0xe0u8, 0xefu8, 0xcau8, 0x3eu8])
-  }
-
-  fn list_cons_addr() -> Addr {
-    store([0x77u8, 0xd5u8, 0x19u8, 0x25u8, 0x9eu8, 0xc9u8, 0xfau8, 0x48u8,
-     0x9du8, 0xbeu8, 0x0eu8, 0x3du8, 0xc0u8, 0xb9u8, 0x35u8, 0x2au8,
-     0xefu8, 0x34u8, 0x9cu8, 0xcdu8, 0xaau8, 0x73u8, 0xeau8, 0x58u8,
-     0xb0u8, 0x8bu8, 0xb0u8, 0xbcu8, 0x68u8, 0x35u8, 0x02u8, 0xa0u8])
-  }
-
-  fn bool_true_addr() -> Addr {
-    store([0xa2u8, 0x9au8, 0x63u8, 0x61u8, 0x76u8, 0xcfu8, 0x11u8, 0x35u8,
-     0xd0u8, 0x77u8, 0xebu8, 0x07u8, 0x47u8, 0x98u8, 0xf9u8, 0x00u8,
-     0x7cu8, 0x78u8, 0xe7u8, 0x80u8, 0x13u8, 0x83u8, 0xe9u8, 0xcfu8,
-     0xf3u8, 0x63u8, 0xbau8, 0xe5u8, 0xedu8, 0xf0u8, 0x57u8, 0x62u8])
-  }
-
-  fn bool_false_addr() -> Addr {
-    store([0xddu8, 0xa1u8, 0x2bu8, 0xcbu8, 0x33u8, 0x07u8, 0x27u8, 0xf6u8,
-     0xdfu8, 0xb8u8, 0x16u8, 0xbcu8, 0x97u8, 0x52u8, 0xaau8, 0xbdu8,
-     0x05u8, 0x20u8, 0xe6u8, 0x51u8, 0x5bu8, 0x79u8, 0xfcu8, 0x8au8,
-     0x5au8, 0x9eu8, 0x71u8, 0x38u8, 0x66u8, 0xf4u8, 0xc6u8, 0x3eu8])
-  }
-
-  -- Mirror: BigUint::succ. Increment a KLimbs by 1; ripple carry.
-  fn klimbs_succ(n: KLimbs) -> KLimbs {
-    match load(n) {
-      ListNode.Nil =>
-        store(ListNode.Cons([1u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], store(ListNode.Nil))),
-      ListNode.Cons(limb, rest) =>
-        let pair = u64_add(limb, [1u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]);
-        match pair {
-          (sum, carry) =>
-            match carry {
-              0 => store(ListNode.Cons(sum, rest)),
-              _ => store(ListNode.Cons(sum, klimbs_succ(rest))),
-            },
-        },
-    }
-  }
-
-  -- Mirror: BigUint::add. Limb-wise add with ripple carry.
-  -- KLimbs are little-endian; head = least significant.
-  -- Asymmetric lengths handled by terminating on shorter list and
-  -- propagating carry into the longer.
-  fn klimbs_add_carry(a: KLimbs, b: KLimbs, carry: G) -> KLimbs {
-    match load(a) {
-      ListNode.Nil =>
-        match carry {
-          0 => b,
-          _ => klimbs_succ(b),
-        },
-      ListNode.Cons(la, ra) =>
-        match load(b) {
-          ListNode.Nil =>
-            match carry {
-              0 => a,
-              _ => klimbs_succ(a),
-            },
-          ListNode.Cons(lb, rb) =>
-            let pair1 = u64_add(la, lb);
-            match pair1 {
-              (sum1, carry1) =>
-                let pair2 = u64_add(sum1, [u8_from_field_unsafe(carry), 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]);
-                match pair2 {
-                  (sum2, carry2) =>
-                    -- carry1, carry2 mutually exclusive: carry1=1 ⇒ sum1 ≤
-                    -- 2^64-2 ⇒ sum1 + carry_in ≤ 2^64-1 ⇒ carry2=0.
-                    let total_carry = to_field(carry1) + to_field(carry2);
-                    store(ListNode.Cons(sum2, klimbs_add_carry(ra, rb, total_carry))),
-                },
-            },
-        },
-    }
-  }
-
-  fn klimbs_add(a: KLimbs, b: KLimbs) -> KLimbs {
-    klimbs_add_carry(a, b, 0)
-  }
-
-  -- Mirror: byte-wise u64_sub with explicit final borrow.
-  -- Per-byte: u_t = borrow(a_i - b_i); u_r = borrow((a_i + 256 - b_i) - br_in).
-  -- u_t = 1 ⇒ a_i + 256 - b_i ≥ 1 ⇒ subtracting br_in ∈ {0,1} cannot underflow
-  -- ⇒ u_r = 0. So `u_t` and `u_r` are mutually-exclusive 0/1 values; field `+`
-  -- substitutes for `g_or` (which charges +1 aux +1 lookup per call). See
-  -- [[reference_aiur_carry_add]].
-  fn u64_sub_with_borrow(a: U64, b: U64) -> (U64, G) {
-    let [a0, a1, a2, a3, a4, a5, a6, a7] = a;
-    let [b0, b1, b2, b3, b4, b5, b6, b7] = b;
-    let (r0, br1) = u8_sub(a0, b0);
-    let (t1, u_t1) = u8_sub(a1, b1);
-    let (r1, u_r1) = u8_sub(t1, br1);
-    let br2 = to_field(u_t1) + to_field(u_r1);
-    let (t2, u_t2) = u8_sub(a2, b2);
-    let (r2, u_r2) = u8_sub(t2, u8_from_field_unsafe(br2));
-    let br3 = to_field(u_t2) + to_field(u_r2);
-    let (t3, u_t3) = u8_sub(a3, b3);
-    let (r3, u_r3) = u8_sub(t3, u8_from_field_unsafe(br3));
-    let br4 = to_field(u_t3) + to_field(u_r3);
-    let (t4, u_t4) = u8_sub(a4, b4);
-    let (r4, u_r4) = u8_sub(t4, u8_from_field_unsafe(br4));
-    let br5 = to_field(u_t4) + to_field(u_r4);
-    let (t5, u_t5) = u8_sub(a5, b5);
-    let (r5, u_r5) = u8_sub(t5, u8_from_field_unsafe(br5));
-    let br6 = to_field(u_t5) + to_field(u_r5);
-    let (t6, u_t6) = u8_sub(a6, b6);
-    let (r6, u_r6) = u8_sub(t6, u8_from_field_unsafe(br6));
-    let br7 = to_field(u_t6) + to_field(u_r6);
-    let (t7, u_t7) = u8_sub(a7, b7);
-    let (r7, u_r7) = u8_sub(t7, u8_from_field_unsafe(br7));
-    let final_borrow = to_field(u_t7) + to_field(u_r7);
-    ([r0, r1, r2, r3, r4, r5, r6, r7], final_borrow)
-  }
-
-  -- Mirror: BigUint::sub with saturating-at-zero (Lean Nat.sub semantics).
-  -- a - b clamped to 0 when b > a.
-  --
-  -- Walk both lists in parallel limb-by-limb with borrow ripple. If the
-  -- final borrow is 1 OR `b` has more limbs than `a`, return 0 (Nil).
-  -- Otherwise normalize trailing zero limbs.
-  fn klimbs_sub_borrow(a: KLimbs, b: KLimbs, borrow: G) -> (KLimbs, G) {
-    match load(a) {
-      ListNode.Nil =>
-        match load(b) {
-          ListNode.Nil =>
-            -- 0 - 0 - borrow: borrow=1 → underflow.
-            (store(ListNode.Nil), borrow),
-          ListNode.Cons(_, _) =>
-            -- 0 - non-empty: definite underflow (b > 0 + carries).
-            (store(ListNode.Nil), 1),
-        },
-      ListNode.Cons(la, ra) =>
-        match load(b) {
-          ListNode.Nil =>
-            -- a - 0 - borrow: subtract borrow from la, propagate.
-            match borrow {
-              0 => (a, 0),
-              _ =>
-                let pair = u64_sub_with_borrow(la, [1u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]);
-                match pair {
-                  (diff, br) =>
-                    let pair2 = klimbs_sub_borrow(ra, store(ListNode.Nil), br);
-                    match pair2 {
-                      (rest_res, br2) =>
-                        (store(ListNode.Cons(diff, rest_res)), br2),
-                    },
-                },
-            },
-          ListNode.Cons(lb, rb) =>
-            let pair1 = u64_sub_with_borrow(la, lb);
-            match pair1 {
-              (sum1, br1) =>
-                let pair2 = u64_sub_with_borrow(sum1, [u8_from_field_unsafe(borrow), 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]);
-                match pair2 {
-                  (sum2, br2) =>
-                    -- br1, br2 mutually exclusive: br1=1 ⇒ sum1 ≥ 1 ⇒
-                    -- sum1 - borrow ≥ 0 ⇒ br2=0.
-                    let total = br1 + br2;
-                    let rec_pair = klimbs_sub_borrow(ra, rb, total);
-                    match rec_pair {
-                      (rest_res, br_final) =>
-                        (store(ListNode.Cons(sum2, rest_res)), br_final),
-                    },
-                },
-            },
-        },
-    }
-  }
-
-  -- Strip trailing zero limbs (canonicalize `[k, 0, 0]` → `[k]`).
-  fn klimbs_normalize(n: KLimbs) -> KLimbs {
-    match load(n) {
-      ListNode.Nil => store(ListNode.Nil),
-      ListNode.Cons(limb, rest) =>
-        let normalized_rest = klimbs_normalize(rest);
-        match load(normalized_rest) {
-          ListNode.Nil =>
-            match u64_is_zero(limb) {
-              1 => store(ListNode.Nil),
-              0 => store(ListNode.Cons(limb, store(ListNode.Nil))),
-            },
-          _ => store(ListNode.Cons(limb, normalized_rest)),
-        },
-    }
-  }
-
-  fn klimbs_sub(a: KLimbs, b: KLimbs) -> KLimbs {
-    let pair = klimbs_sub_borrow(a, b, 0);
-    match pair {
-      (result, borrow) =>
-        match borrow {
-          1 => store(ListNode.Nil),
-          0 => klimbs_normalize(result),
-        },
-    }
-  }
-
-  -- Mirror: Nat.le. Returns 1 if a ≤ b, 0 otherwise.
-  -- Uses saturating sub: a ≤ b iff (a - b) saturates to 0.
-  fn klimbs_le(a: KLimbs, b: KLimbs) -> G {
-    let diff = klimbs_sub(a, b);
-    match load(diff) {
-      ListNode.Nil => 1,
-      _ => 0,
-    }
-  }
-
-  -- Mirror: Nat.pred. Saturating decrement; pred(0) = 0.
-  fn klimbs_dec(a: KLimbs) -> KLimbs {
-    let one = store(ListNode.Cons([1u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], store(ListNode.Nil)));
-    klimbs_sub(a, one)
-  }
-
-  -- Returns (remainder, quotient): remainder = x mod 256, quotient = x / 256.
-  -- Repeated subtraction. Only ever invoked from the `#split_carry` /
-  -- `#split_u32` unconstrained witness generators, so the O(x/256)
-  -- iteration cost is off-circuit (untraced).
-  fn divmod_256(x: G, q: G) -> (G, G) {
-    match u32_less_than(x, 256) {
-      1 => (x, q),
-      0 => divmod_256(x - 256, q + 1),
-    }
-  }
-
-  -- Unconstrained witness generator: split `x` into its low byte `limb`
-  -- and the two bytes (clo, chi) of `x div 256`. Always invoked as
-  -- `#split_carry(...)`; the result is prover-provided and MUST be pinned
-  -- by the caller with u8 range checks + a reconstruction assert. The
-  -- division here is off-circuit (untraced), so its cost is irrelevant.
-  fn split_carry(x: G) -> (G, G, G) {
-    match divmod_256(x, 0) {
-      (limb, quot) =>
-        match divmod_256(quot, 0) {
-          (clo, chi) => (limb, clo, chi),
-        },
-    }
-  }
-
-  -- u64×u64 → (lo: U64, hi: U64) via byte schoolbook. Faithful port of the
-  -- `MulWitness`/`Product` reference: column k is the raw field sum
-  -- Σ_{i+j=k} a[i]*b[j]; each column accumulator `out` is decomposed by a
-  -- prover-provided (unconstrained) split into result byte + 16-bit carry,
-  -- then pinned by three u8 range checks (`u8_xor(_, 0)`) and the
-  -- reconstruction assert `out == limb + 256·clo + 65536·chi`. No `u8_mul`
-  -- gadget and no constrained division. Column accumulators are < 2^19, so
-  -- the decomposition into (limb, clo, chi) ∈ [0,256)³ is unique → sound.
-  fn u64_mul(a: U64, b: U64) -> (U64, U64) {
-    let [a0, a1, a2, a3, a4, a5, a6, a7] = a;
-    let [b0, b1, b2, b3, b4, b5, b6, b7] = b;
-    let col0 = (to_field(a0) * to_field(b0));
-    let col1 = (to_field(a0) * to_field(b1)) + (to_field(a1) * to_field(b0));
-    let col2 = (to_field(a0) * to_field(b2)) + (to_field(a1) * to_field(b1)) + (to_field(a2) * to_field(b0));
-    let col3 = (to_field(a0) * to_field(b3)) + (to_field(a1) * to_field(b2)) + (to_field(a2) * to_field(b1)) + (to_field(a3) * to_field(b0));
-    let col4 = (to_field(a0) * to_field(b4)) + (to_field(a1) * to_field(b3)) + (to_field(a2) * to_field(b2)) + (to_field(a3) * to_field(b1)) + (to_field(a4) * to_field(b0));
-    let col5 = (to_field(a0) * to_field(b5)) + (to_field(a1) * to_field(b4)) + (to_field(a2) * to_field(b3)) + (to_field(a3) * to_field(b2)) + (to_field(a4) * to_field(b1)) + (to_field(a5) * to_field(b0));
-    let col6 = (to_field(a0) * to_field(b6)) + (to_field(a1) * to_field(b5)) + (to_field(a2) * to_field(b4)) + (to_field(a3) * to_field(b3)) + (to_field(a4) * to_field(b2)) + (to_field(a5) * to_field(b1)) + (to_field(a6) * to_field(b0));
-    let col7 = (to_field(a0) * to_field(b7)) + (to_field(a1) * to_field(b6)) + (to_field(a2) * to_field(b5)) + (to_field(a3) * to_field(b4)) + (to_field(a4) * to_field(b3)) + (to_field(a5) * to_field(b2)) + (to_field(a6) * to_field(b1)) + (to_field(a7) * to_field(b0));
-    let col8 = (to_field(a1) * to_field(b7)) + (to_field(a2) * to_field(b6)) + (to_field(a3) * to_field(b5)) + (to_field(a4) * to_field(b4)) + (to_field(a5) * to_field(b3)) + (to_field(a6) * to_field(b2)) + (to_field(a7) * to_field(b1));
-    let col9 = (to_field(a2) * to_field(b7)) + (to_field(a3) * to_field(b6)) + (to_field(a4) * to_field(b5)) + (to_field(a5) * to_field(b4)) + (to_field(a6) * to_field(b3)) + (to_field(a7) * to_field(b2));
-    let col10 = (to_field(a3) * to_field(b7)) + (to_field(a4) * to_field(b6)) + (to_field(a5) * to_field(b5)) + (to_field(a6) * to_field(b4)) + (to_field(a7) * to_field(b3));
-    let col11 = (to_field(a4) * to_field(b7)) + (to_field(a5) * to_field(b6)) + (to_field(a6) * to_field(b5)) + (to_field(a7) * to_field(b4));
-    let col12 = (to_field(a5) * to_field(b7)) + (to_field(a6) * to_field(b6)) + (to_field(a7) * to_field(b5));
-    let col13 = (to_field(a6) * to_field(b7)) + (to_field(a7) * to_field(b6));
-    let col14 = (to_field(a7) * to_field(b7));
-    match #split_carry(col0) {
-      (rl0, rc0, rh0) =>
-        let r0 = u8_xor(u8_from_field_unsafe(rl0), 0u8);
-        let lo0 = u8_xor(u8_from_field_unsafe(rc0), 0u8);
-        let hi0 = u8_xor(u8_from_field_unsafe(rh0), 0u8);
-        assert_eq!(col0, to_field(r0) + (256 * to_field(lo0)) + (65536 * to_field(hi0)));
-        let out1 = col1 + to_field(lo0) + (256 * to_field(hi0));
-        match #split_carry(out1) {
-          (rl1, rc1, rh1) =>
-            let r1 = u8_xor(u8_from_field_unsafe(rl1), 0u8);
-            let lo1 = u8_xor(u8_from_field_unsafe(rc1), 0u8);
-            let hi1 = u8_xor(u8_from_field_unsafe(rh1), 0u8);
-            assert_eq!(out1, to_field(r1) + (256 * to_field(lo1)) + (65536 * to_field(hi1)));
-            let out2 = col2 + to_field(lo1) + (256 * to_field(hi1));
-            match #split_carry(out2) {
-              (rl2, rc2, rh2) =>
-                let r2 = u8_xor(u8_from_field_unsafe(rl2), 0u8);
-                let lo2 = u8_xor(u8_from_field_unsafe(rc2), 0u8);
-                let hi2 = u8_xor(u8_from_field_unsafe(rh2), 0u8);
-                assert_eq!(out2, to_field(r2) + (256 * to_field(lo2)) + (65536 * to_field(hi2)));
-                let out3 = col3 + to_field(lo2) + (256 * to_field(hi2));
-                match #split_carry(out3) {
-                  (rl3, rc3, rh3) =>
-                    let r3 = u8_xor(u8_from_field_unsafe(rl3), 0u8);
-                    let lo3 = u8_xor(u8_from_field_unsafe(rc3), 0u8);
-                    let hi3 = u8_xor(u8_from_field_unsafe(rh3), 0u8);
-                    assert_eq!(out3, to_field(r3) + (256 * to_field(lo3)) + (65536 * to_field(hi3)));
-                    let out4 = col4 + to_field(lo3) + (256 * to_field(hi3));
-                    match #split_carry(out4) {
-                      (rl4, rc4, rh4) =>
-                        let r4 = u8_xor(u8_from_field_unsafe(rl4), 0u8);
-                        let lo4 = u8_xor(u8_from_field_unsafe(rc4), 0u8);
-                        let hi4 = u8_xor(u8_from_field_unsafe(rh4), 0u8);
-                        assert_eq!(out4, to_field(r4) + (256 * to_field(lo4)) + (65536 * to_field(hi4)));
-                        let out5 = col5 + to_field(lo4) + (256 * to_field(hi4));
-                        match #split_carry(out5) {
-                          (rl5, rc5, rh5) =>
-                            let r5 = u8_xor(u8_from_field_unsafe(rl5), 0u8);
-                            let lo5 = u8_xor(u8_from_field_unsafe(rc5), 0u8);
-                            let hi5 = u8_xor(u8_from_field_unsafe(rh5), 0u8);
-                            assert_eq!(out5, to_field(r5) + (256 * to_field(lo5)) + (65536 * to_field(hi5)));
-                            let out6 = col6 + to_field(lo5) + (256 * to_field(hi5));
-                            match #split_carry(out6) {
-                              (rl6, rc6, rh6) =>
-                                let r6 = u8_xor(u8_from_field_unsafe(rl6), 0u8);
-                                let lo6 = u8_xor(u8_from_field_unsafe(rc6), 0u8);
-                                let hi6 = u8_xor(u8_from_field_unsafe(rh6), 0u8);
-                                assert_eq!(out6, to_field(r6) + (256 * to_field(lo6)) + (65536 * to_field(hi6)));
-                                let out7 = col7 + to_field(lo6) + (256 * to_field(hi6));
-                                match #split_carry(out7) {
-                                  (rl7, rc7, rh7) =>
-                                    let r7 = u8_xor(u8_from_field_unsafe(rl7), 0u8);
-                                    let lo7 = u8_xor(u8_from_field_unsafe(rc7), 0u8);
-                                    let hi7 = u8_xor(u8_from_field_unsafe(rh7), 0u8);
-                                    assert_eq!(out7, to_field(r7) + (256 * to_field(lo7)) + (65536 * to_field(hi7)));
-                                    let out8 = col8 + to_field(lo7) + (256 * to_field(hi7));
-                                    match #split_carry(out8) {
-                                      (rl8, rc8, rh8) =>
-                                        let r8 = u8_xor(u8_from_field_unsafe(rl8), 0u8);
-                                        let lo8 = u8_xor(u8_from_field_unsafe(rc8), 0u8);
-                                        let hi8 = u8_xor(u8_from_field_unsafe(rh8), 0u8);
-                                        assert_eq!(out8, to_field(r8) + (256 * to_field(lo8)) + (65536 * to_field(hi8)));
-                                        let out9 = col9 + to_field(lo8) + (256 * to_field(hi8));
-                                        match #split_carry(out9) {
-                                          (rl9, rc9, rh9) =>
-                                            let r9 = u8_xor(u8_from_field_unsafe(rl9), 0u8);
-                                            let lo9 = u8_xor(u8_from_field_unsafe(rc9), 0u8);
-                                            let hi9 = u8_xor(u8_from_field_unsafe(rh9), 0u8);
-                                            assert_eq!(out9, to_field(r9) + (256 * to_field(lo9)) + (65536 * to_field(hi9)));
-                                            let out10 = col10 + to_field(lo9) + (256 * to_field(hi9));
-                                            match #split_carry(out10) {
-                                              (rl10, rc10, rh10) =>
-                                                let r10 = u8_xor(u8_from_field_unsafe(rl10), 0u8);
-                                                let lo10 = u8_xor(u8_from_field_unsafe(rc10), 0u8);
-                                                let hi10 = u8_xor(u8_from_field_unsafe(rh10), 0u8);
-                                                assert_eq!(out10, to_field(r10) + (256 * to_field(lo10)) + (65536 * to_field(hi10)));
-                                                let out11 = col11 + to_field(lo10) + (256 * to_field(hi10));
-                                                match #split_carry(out11) {
-                                                  (rl11, rc11, rh11) =>
-                                                    let r11 = u8_xor(u8_from_field_unsafe(rl11), 0u8);
-                                                    let lo11 = u8_xor(u8_from_field_unsafe(rc11), 0u8);
-                                                    let hi11 = u8_xor(u8_from_field_unsafe(rh11), 0u8);
-                                                    assert_eq!(out11, to_field(r11) + (256 * to_field(lo11)) + (65536 * to_field(hi11)));
-                                                    let out12 = col12 + to_field(lo11) + (256 * to_field(hi11));
-                                                    match #split_carry(out12) {
-                                                      (rl12, rc12, rh12) =>
-                                                        let r12 = u8_xor(u8_from_field_unsafe(rl12), 0u8);
-                                                        let lo12 = u8_xor(u8_from_field_unsafe(rc12), 0u8);
-                                                        let hi12 = u8_xor(u8_from_field_unsafe(rh12), 0u8);
-                                                        assert_eq!(out12, to_field(r12) + (256 * to_field(lo12)) + (65536 * to_field(hi12)));
-                                                        let out13 = col13 + to_field(lo12) + (256 * to_field(hi12));
-                                                        match #split_carry(out13) {
-                                                          (rl13, rc13, rh13) =>
-                                                            let r13 = u8_xor(u8_from_field_unsafe(rl13), 0u8);
-                                                            let lo13 = u8_xor(u8_from_field_unsafe(rc13), 0u8);
-                                                            let hi13 = u8_xor(u8_from_field_unsafe(rh13), 0u8);
-                                                            assert_eq!(out13, to_field(r13) + (256 * to_field(lo13)) + (65536 * to_field(hi13)));
-                                                            let out14 = col14 + to_field(lo13) + (256 * to_field(hi13));
-                                                            match #split_carry(out14) {
-                                                              (rl14, rc14, rh14) =>
-                                                                let r14 = u8_xor(u8_from_field_unsafe(rl14), 0u8);
-                                                                let lo14 = u8_xor(u8_from_field_unsafe(rc14), 0u8);
-                                                                let hi14 = u8_xor(u8_from_field_unsafe(rh14), 0u8);
-                                                                assert_eq!(out14, to_field(r14) + (256 * to_field(lo14)) + (65536 * to_field(hi14)));
-                                                                let r15 = u8_from_field_unsafe(to_field(lo14) + (256 * to_field(hi14)));
-                                                                ([r0, r1, r2, r3, r4, r5, r6, r7],
-                                                                 [r8, r9, r10, r11, r12, r13, r14, r15]),
-                                                            },
-                                                        },
-                                                    },
-                                                },
-                                            },
-                                        },
-                                    },
-                                },
-                            },
-                        },
-                    },
-                },
-            },
-        },
-    }
-  }
-
-  -- Mirror: BigUint::mul. Limb-wise schoolbook multiply.
-  fn klimbs_mul(a: KLimbs, b: KLimbs) -> KLimbs {
-    klimbs_mul_outer(a, b, store(ListNode.Nil), 0)
-  }
-
-  fn klimbs_mul_outer(a: KLimbs, b: KLimbs, acc: KLimbs, shift: G) -> KLimbs {
-    match load(a) {
-      ListNode.Nil => acc,
-      ListNode.Cons(a_limb, rest) =>
-        let prod = klimbs_mul_single(a_limb, b, [0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], store(ListNode.Nil));
-        let shifted = klimbs_shl_limbs(prod, shift);
-        let new_acc = klimbs_add(acc, shifted);
-        klimbs_mul_outer(rest, b, new_acc, shift + 1),
-    }
-  }
-
-  fn klimbs_mul_single(a_limb: U64, b: KLimbs, carry: U64, acc: KLimbs) -> KLimbs {
-    match load(b) {
-      ListNode.Nil =>
-        match u64_is_zero(carry) {
-          1 => acc,
-          0 => list_snoc(acc, carry),
-        },
-      ListNode.Cons(b_limb, rest) =>
-        match u64_mul(a_limb, b_limb) {
-          (lo, hi) =>
-            match u64_add(lo, carry) {
-              (sum, carry_out) =>
-                match u64_add(hi, [carry_out, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]) {
-                  (new_carry, _) =>
-                    let new_acc = list_snoc(acc, sum);
-                    klimbs_mul_single(a_limb, rest, new_carry, new_acc),
-                },
-            },
-        },
-    }
-  }
-
-  fn klimbs_shl_limbs(x: KLimbs, shift: G) -> KLimbs {
-    match shift {
-      0 => x,
-      _ =>
-        let prepended = store(ListNode.Cons([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], x));
-        klimbs_shl_limbs(prepended, shift - 1),
-    }
-  }
-
-  fn klimbs_is_zero(x: KLimbs) -> G {
-    match load(klimbs_normalize(x)) {
-      ListNode.Nil => 1,
-      _ => 0,
-    }
-  }
-
-  -- Unconstrained Aiur op `unconstrained_big_uint_div_mod(a, b) -> (q, r)`
-  -- pushes prover-supplied (q, r) into the trace map; no constraints emitted
-  -- by the op itself. Caller verifies `q*b + r == a` (under normalize) and
-  -- `r < b` when `b != 0`. For `b == 0` the op returns `(0, a)`; only the
-  -- `q*b + r == a` equality is required (which holds: `0*0 + a == a`).
-  --
-  -- Soundness on the prover-supplied bytes: every limb byte flows through
-  -- u8_mul inside `klimbs_mul(q, b)` and u8_add inside `klimbs_add(qb, r)`,
-  -- both of which push to the u8_range_check channel
-  -- (src/aiur/gadgets/bytes2.rs), so a byte > 255 fails the gadget's range
-  -- check. Trailing junk limbs that mul doesn't touch are caught by the
-  -- post-normalize equality below.
-  fn klimbs_div_mod(a: KLimbs, b: KLimbs) -> (KLimbs, KLimbs) {
-    let (q, r) = unconstrained_big_uint_div_mod(a, b);
-    let qb = klimbs_mul(q, b);
-    let lhs = klimbs_normalize(klimbs_add(qb, r));
-    let rhs = klimbs_normalize(a);
-    assert_eq!(lhs, rhs);
-    match klimbs_is_zero(b) {
-      1 => (q, r),
-      0 =>
-        -- r < b iff (r + 1) ≤ b. One klimbs_le on klimbs_succ(r); cheapest
-        -- of the sound variants empirically (vs `le(r,b)∧¬eq(r,b)` or
-        -- `¬le(b,r)`).
-        assert_eq!(klimbs_le(klimbs_succ(r), b), 1);
-        (q, r),
-    }
-  }
-
-  fn klimbs_div(a: KLimbs, b: KLimbs) -> KLimbs {
-    match klimbs_div_mod(a, b) { (q, _) => q, }
-  }
-
-  fn klimbs_mod(a: KLimbs, b: KLimbs) -> KLimbs {
-    match klimbs_div_mod(a, b) { (_, r) => r, }
-  }
-
-  fn klimbs_gcd(a: KLimbs, b: KLimbs) -> KLimbs {
-    match klimbs_is_zero(b) {
-      1 => a,
-      0 => klimbs_gcd(b, klimbs_mod(a, b)),
-    }
-  }
-
-  -- Binary exponentiation. Replaces the old O(exp) recursive
-  -- `klimbs_mul(base, klimbs_pow(base, klimbs_dec(exp)))` body, which
-  -- created one per-fn memo row per exponent step and OOM'd for
-  -- non-trivial exponents. Recursion depth is `log2(exp)` — for
-  -- `exp = 2^32` that's 32 memo entries instead of 4 billion.
-  --
-  -- Both `klimbs_div2` (= `klimbs_div(exp, 2)`) and `klimbs_is_odd`
-  -- (= `klimbs_mod(exp, 2) != 0`) route through `klimbs_div_mod`, which
-  -- is itself native (unconstrained_big_uint_div_mod) — so the
-  -- division per step is O(1) work.
-  fn klimbs_pow(base: KLimbs, exp: KLimbs) -> KLimbs {
-    match klimbs_is_zero(exp) {
-      1 => store(ListNode.Cons([1u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], store(ListNode.Nil))),
-      0 =>
-        let two = store(ListNode.Cons([2u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], store(ListNode.Nil)));
-        let (half, r) = klimbs_div_mod(exp, two);
-        let sq = klimbs_pow(klimbs_normalize(klimbs_mul(base, base)), klimbs_normalize(half));
-        match klimbs_is_zero(r) {
-          1 => sq,
-          0 => klimbs_mul(base, sq),
-        },
-    }
-  }
-
-  -- Byte-wise AND on two U64 limbs.
-  fn u64_and(a: U64, b: U64) -> U64 {
-    let [a0, a1, a2, a3, a4, a5, a6, a7] = a;
-    let [b0, b1, b2, b3, b4, b5, b6, b7] = b;
-    [u8_and(a0, b0), u8_and(a1, b1), u8_and(a2, b2), u8_and(a3, b3),
-     u8_and(a4, b4), u8_and(a5, b5), u8_and(a6, b6), u8_and(a7, b7)]
-  }
-
-  fn u64_or(a: U64, b: U64) -> U64 {
-    let [a0, a1, a2, a3, a4, a5, a6, a7] = a;
-    let [b0, b1, b2, b3, b4, b5, b6, b7] = b;
-    [u8_or(a0, b0), u8_or(a1, b1), u8_or(a2, b2), u8_or(a3, b3),
-     u8_or(a4, b4), u8_or(a5, b5), u8_or(a6, b6), u8_or(a7, b7)]
-  }
-
-  fn u64_xor_kbits(a: U64, b: U64) -> U64 {
-    let [a0, a1, a2, a3, a4, a5, a6, a7] = a;
-    let [b0, b1, b2, b3, b4, b5, b6, b7] = b;
-    [u8_xor(a0, b0), u8_xor(a1, b1), u8_xor(a2, b2), u8_xor(a3, b3),
-     u8_xor(a4, b4), u8_xor(a5, b5), u8_xor(a6, b6), u8_xor(a7, b7)]
-  }
-
-  -- Mirror: BigUint::bitand. Walks parallel limbs; result length = min(len(a), len(b)).
-  fn klimbs_land(a: KLimbs, b: KLimbs) -> KLimbs {
-    match load(a) {
-      ListNode.Nil => store(ListNode.Nil),
-      ListNode.Cons(la, ra) =>
-        match load(b) {
-          ListNode.Nil => store(ListNode.Nil),
-          ListNode.Cons(lb, rb) =>
-            store(ListNode.Cons(u64_and(la, lb), klimbs_land(ra, rb))),
-        },
-    }
-  }
-
-  -- Mirror: BigUint::bitor. Result length = max(len(a), len(b)); shorter is zero-padded.
-  fn klimbs_lor(a: KLimbs, b: KLimbs) -> KLimbs {
-    match load(a) {
-      ListNode.Nil => b,
-      ListNode.Cons(la, ra) =>
-        match load(b) {
-          ListNode.Nil => a,
-          ListNode.Cons(lb, rb) =>
-            store(ListNode.Cons(u64_or(la, lb), klimbs_lor(ra, rb))),
-        },
-    }
-  }
-
-  -- Mirror: BigUint::bitxor. Result length = max(len(a), len(b)); zero-padded shorter.
-  fn klimbs_xor_op(a: KLimbs, b: KLimbs) -> KLimbs {
-    match load(a) {
-      ListNode.Nil => b,
-      ListNode.Cons(la, ra) =>
-        match load(b) {
-          ListNode.Nil => a,
-          ListNode.Cons(lb, rb) =>
-            store(ListNode.Cons(u64_xor_kbits(la, lb), klimbs_xor_op(ra, rb))),
-        },
-    }
-  }
-
-  -- Shift left by n bits via repeated multiplication by 2.
-  fn klimbs_shl(a: KLimbs, n: KLimbs) -> KLimbs {
-    let two = store(ListNode.Cons([2u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], store(ListNode.Nil)));
-    klimbs_mul(a, klimbs_pow(two, n))
-  }
-
-  -- Shift right by n bits via integer division by 2^n.
-  fn klimbs_shr(a: KLimbs, n: KLimbs) -> KLimbs {
-    let two = store(ListNode.Cons([2u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], store(ListNode.Nil)));
-    klimbs_div(a, klimbs_pow(two, n))
-  }
-
-  -- ============================================================================
-  -- Lit(Nat) extraction + dispatch
-  -- ============================================================================
-
-  -- Find target's positional idx in addrs. Returns (1, idx) if found,
-  -- (0, _) if not. Used by Nat literal coercion in iota.
-  fn find_addr_idx_safe(target: Addr, addrs: List‹Addr›, i: G) -> (G, G) {
-    match load(addrs) {
-      ListNode.Nil => (0, 0),
-      ListNode.Cons(a, rest) =>
-        match address_eq(target, a) {
-          1 => (1, i),
-          0 => find_addr_idx_safe(target, rest, i + 1),
-        },
-    }
-  }
-
-  -- If `e` is `Lit(Nat(klimbs))` and addrs contains both Nat.zero and
-  -- Nat.succ, expose ONE constructor layer: `0 -> Const(zero)`,
-  -- `n -> App(Const(succ), Lit(n-1))`. Else return `e` unchanged. Mirror:
-  -- src/ix/kernel/whnf.rs nat_to_constructor (one level, matching lean4
-  -- inductive.h:91-93 and lean4lean Reduce.lean:70).
-  --
-  -- One level, NOT the full succ chain: iota only needs the outermost
-  -- ctor to fire, and the predecessor stays a compact literal that
-  -- downstream whnf/def_eq/extract hit via the Nat fast paths. A full
-  -- `succ^n(zero)` chain materialized n fresh nodes per expansion event
-  -- and made every traversal of the major O(n) with distinct memo keys
-  -- per depth.
-  fn nat_lit_to_ctor_or_self(e: KExpr, addrs: List‹Addr›) -> KExpr {
-    match load(e) {
-      KExprNode.Lit(lit) =>
-        match lit {
-          KLiteral.Nat(klimbs) =>
-            let z = find_addr_idx_safe(nat_zero_addr(), addrs, 0);
-            let s = find_addr_idx_safe(nat_succ_addr(), addrs, 0);
-            match z {
-              (1, zero_idx) =>
-                match s {
-                  (1, succ_idx) =>
-                    match load(klimbs) {
-                      ListNode.Nil =>
-                        store(KExprNode.Const(zero_idx, store(ListNode.Nil))),
-                      ListNode.Cons(_, _) =>
-                        -- klimbs_dec at a limb boundary (e.g. 2^32 = [0,1] →
-                        -- [0xFFFFFFFF, 0]) leaves a trailing zero limb; without
-                        -- normalization the countdown reaches a Cons-shaped zero
-                        -- ([0,0]) that takes this succ arm again and decrements
-                        -- past zero — an unbounded descent. Canonical limbs also
-                        -- keep the per-layer Lit nodes shared in the memo.
-                        let pred = store(KExprNode.Lit(KLiteral.Nat(klimbs_normalize(klimbs_dec(klimbs)))));
-                        let succ_const = store(KExprNode.Const(succ_idx, store(ListNode.Nil)));
-                        store(KExprNode.App(succ_const, pred)),
-                    },
-                  _ => e,
-                },
-              _ => e,
-            },
-          _ => e,
-        },
-      _ => e,
-    }
-  }
-
-  -- Mirror: src/ix/kernel/whnf.rs::extract_nat_value. Accepts:
-  --   * `Lit(Nat klimbs)` → klimbs
-  --   * `Const(Nat.zero)` → 0
-  --   * `App(Const(Nat.succ), x)` → 1 + extract(x)
-  fn try_extract_nat(e: KExpr, addrs: List‹Addr›) -> (G, KLimbs) {
-    match load(e) {
-      KExprNode.Lit(lit) =>
-        match lit {
-          KLiteral.Nat(limbs) => (1, limbs),
-          _ => (0, store(ListNode.Nil)),
-        },
-      KExprNode.Const(idx, _) =>
-        let const_addr = list_lookup(addrs, idx);
-        match address_eq(const_addr, nat_zero_addr()) {
-          1 => (1, store(ListNode.Nil)),
-          0 => (0, store(ListNode.Nil)),
-        },
-      KExprNode.App(f, a) => try_extract_nat_app(f, a, addrs),
-      _ => (0, store(ListNode.Nil)),
-    }
-  }
-
-  -- Cold-extracted App arm: list_lookup + address_eq + recursive
-  -- try_extract_nat + klimbs_succ is the widest arm; pulling it out lets
-  -- `try_extract_nat`'s main width drop to the leaf-arm width.
-  fn try_extract_nat_app(f: KExpr, a: KExpr, addrs: List‹Addr›) -> (G, KLimbs) {
-    match load(f) {
-      KExprNode.Const(idx, _) =>
-        let head_addr_ = list_lookup(addrs, idx);
-        match address_eq(head_addr_, nat_succ_addr()) {
-          1 =>
-            match try_extract_nat(a, addrs) {
-              (1, pred_limbs) => (1, klimbs_succ(pred_limbs)),
-              _ => (0, store(ListNode.Nil)),
-            },
-          0 => (0, store(ListNode.Nil)),
-        },
-      _ => (0, store(ListNode.Nil)),
-    }
-  }
-
-  -- Wrap a KLimbs in `Lit(Nat(...))`.
-  fn mk_nat_lit(n: KLimbs) -> KExpr {
-    store(KExprNode.Lit(KLiteral.Nat(n)))
-  }
-
-  -- Build the compact stuck offset `Nat.add base (Lit n)` applied to `post`,
-  -- the canonical normal form for a symbolic-base Nat offset (paired with
-  -- offset-aware def-eq). n = 0 collapses to `base` directly. Shared by the
-  -- nat dispatch (symbolic add/div/mod kept stuck) and the linear-rec
-  -- collapse, keeping the offset construction out of those circuits' width.
-  fn mk_nat_offset_stuck(base_w: KExpr, n: KLimbs, post: List‹KExpr›,
-                         addrs: List‹Addr›) -> (G, KExpr) {
-    match klimbs_is_zero(n) {
-      1 => (1, apply_spine(base_w, post)),
-      0 =>
-        match find_addr_idx_safe(nat_add_addr(), addrs, 0) {
-          (0, _) => (0, store(KExprNode.BVar(0))),
-          (1, add_idx) =>
-            let add_const = store(KExprNode.Const(add_idx, store(ListNode.Nil)));
-            let off = store(KExprNode.App(
-              store(KExprNode.App(add_const, base_w)),
-              mk_nat_lit(n)));
-            (1, apply_spine(off, post)),
-        },
-    }
-  }
-
-  -- ============================================================================
-  -- Primitive-family classification
-  --
-  -- `prim_family(a)` maps a Const-head address to the one reducer family
-  -- that could possibly fire on it: 0 = none, 1 = nat (`try_nat_dispatch`),
-  -- 2 = str, 3 = bitvec, 4 = native, 5 = decidable. The family address
-  -- sets are mutually disjoint (verified against each reducer's
-  -- comparisons), so classification is unambiguous.
-  --
-  -- Keyed on the ADDRESS ALONE: one memo row per distinct constant
-  -- address in the whole run (~hundreds), and the inner `address_eq`
-  -- chains are likewise keyed `(a, prim)` so they collapse after the
-  -- first occurrence of each address. This replaces running every
-  -- reducer as a gauntlet from `whnf_const_head`, whose try_* keys
-  -- include the spine and context — 4-6 wide rows per Const-head whnf,
-  -- almost all guaranteed misses.
-  -- ============================================================================
-  fn prim_family(a: Addr) -> G {
-    match is_nat_prim_addr(a) {
-      1 => 1,
-      0 =>
-        match is_str_prim_addr(a) {
-          1 => 2,
-          0 =>
-            match is_bitvec_prim_addr(a) {
-              1 => 3,
-              0 =>
-                match is_native_prim_addr(a) {
-                  1 => 4,
-                  0 =>
-                    match is_decidable_prim_addr(a) {
-                      1 => 5,
-                      0 => 0,
-                    },
-                },
-            },
-        },
-    }
-  }
-
-  -- Addresses handled by `try_nat_dispatch`: succ/pred plus the binop
-  -- set of `try_nat_binop_addr`.
-  fn is_nat_prim_addr(a: Addr) -> G {
-    match address_eq(a, nat_succ_addr()) {
-      1 => 1,
-      0 =>
-      match address_eq(a, nat_pred_addr()) {
-        1 => 1,
-        0 =>
-        match address_eq(a, nat_add_addr()) {
-          1 => 1,
-          0 =>
-          match address_eq(a, nat_sub_addr()) {
-            1 => 1,
-            0 =>
-            match address_eq(a, nat_mul_addr()) {
-              1 => 1,
-              0 =>
-              match address_eq(a, nat_div_addr()) {
-                1 => 1,
-                0 =>
-                match address_eq(a, nat_mod_addr()) {
-                  1 => 1,
-                  0 =>
-                  match address_eq(a, nat_pow_addr()) {
-                    1 => 1,
-                    0 =>
-                    match address_eq(a, nat_gcd_addr()) {
-                      1 => 1,
-                      0 =>
-                      match address_eq(a, nat_beq_addr()) {
-                        1 => 1,
-                        0 =>
-                        match address_eq(a, nat_ble_addr()) {
-                          1 => 1,
-                          0 =>
-                          match address_eq(a, nat_land_addr()) {
-                            1 => 1,
-                            0 =>
-                            match address_eq(a, nat_lor_addr()) {
-                              1 => 1,
-                              0 =>
-                              match address_eq(a, nat_xor_addr()) {
-                                1 => 1,
-                                0 =>
-                                match address_eq(a, nat_shift_left_addr()) {
-                                  1 => 1,
-                                  0 =>
-                                  match address_eq(a, nat_shift_right_addr()) {
-                                    1 => 1,
-                                    0 =>
-                                    0,
-                                  },
-                                },
-                              },
-                            },
-                          },
-                        },
-                      },
-                    },
-                  },
-                },
-              },
-            },
-          },
-        },
-      },
-    }
-  }
-
-  -- Addresses handled by `try_str_dispatch`.
-  fn is_str_prim_addr(a: Addr) -> G {
-    match address_eq(a, string_utf8_byte_size_addr()) {
-      1 => 1,
-      0 =>
-      match address_eq(a, string_to_byte_array_addr()) {
-        1 => 1,
-        0 =>
-        match address_eq(a, string_back_addr()) {
-          1 => 1,
-          0 =>
-          match address_eq(a, string_legacy_back_addr()) {
-            1 => 1,
-            0 =>
-            match address_eq(a, string_append_addr()) {
-              1 => 1,
-              0 =>
-              match address_eq(a, string_dec_eq_addr()) {
-                1 => 1,
-                0 =>
-                match address_eq(a, string_of_list_addr()) {
-                  1 => 1,
-                  0 =>
-                  0,
-                },
-              },
-            },
-          },
-        },
-      },
-    }
-  }
-
-  -- Addresses handled by `try_bitvec_dispatch`.
-  fn is_bitvec_prim_addr(a: Addr) -> G {
-    match address_eq(a, bit_vec_to_nat_addr()) {
-      1 => 1,
-      0 =>
-      match address_eq(a, bit_vec_ult_addr()) {
-        1 => 1,
-        0 =>
-        match address_eq(a, decidable_decide_addr()) {
-          1 => 1,
-          0 =>
-          0,
-        },
-      },
-    }
-  }
-
-  -- Addresses handled by `try_reduce_native`.
-  fn is_native_prim_addr(a: Addr) -> G {
-    match address_eq(a, reduce_bool_addr()) {
-      1 => 1,
-      0 =>
-      match address_eq(a, reduce_nat_addr()) {
-        1 => 1,
-        0 =>
-        match address_eq(a, subtype_val_addr()) {
-          1 => 1,
-          0 =>
-          match address_eq(a, size_of_size_of_addr()) {
-            1 => 1,
-            0 =>
-            match address_eq(a, punit_size_of_1_addr()) {
-              1 => 1,
-              0 =>
-              match address_eq(a, system_platform_num_bits_addr()) {
-                1 => 1,
-                0 =>
-                0,
-              },
-            },
-          },
-        },
-      },
-    }
-  }
-
-  -- Addresses handled by `try_reduce_decidable`.
-  fn is_decidable_prim_addr(a: Addr) -> G {
-    match address_eq(a, nat_dec_eq_addr()) {
-      1 => 1,
-      0 =>
-      match address_eq(a, nat_dec_lt_addr()) {
-        1 => 1,
-        0 =>
-        match address_eq(a, nat_dec_le_addr()) {
-          1 => 1,
-          0 =>
-          match address_eq(a, int_dec_eq_addr()) {
-            1 => 1,
-            0 =>
-            match address_eq(a, int_dec_lt_addr()) {
-              1 => 1,
-              0 =>
-              match address_eq(a, int_dec_le_addr()) {
-                1 => 1,
-                0 =>
-                0,
-              },
-            },
-          },
-        },
-      },
-    }
-  }
-
-  -- Mirror: src/ix/kernel/whnf.rs:500-700 Nat-on-literals dispatch.
-  -- Address-keyed (no positional prims): given the head Const's blake3
-  -- address and the unreduced spine, fold a Nat primitive op when both
-  -- required args are literals. Returns (1, reduced) on hit, (0, _) on miss.
-  fn try_nat_dispatch(head_addr: Addr, spine: List‹KExpr›,
-                      types: List‹KExpr›, top: List‹&KConstantInfo›,
-                      addrs: List‹Addr›) -> (G, KExpr) {
-    let spine_len = list_length(spine);
-    let is_pred = address_eq(head_addr, nat_pred_addr());
-    let is_succ = address_eq(head_addr, nat_succ_addr());
-    match is_succ {
-      1 =>
-        match u32_less_than(spine_len, 1) {
-          1 => (0, store(KExprNode.BVar(0))),
-          0 =>
-            let a0_w = whnf(list_lookup(spine, 0), types, top, addrs);
-            match try_extract_nat(a0_w, addrs) {
-              (1, na) =>
-                let post = list_drop(spine, 1);
-                (1, apply_spine(mk_nat_lit(klimbs_succ(na)), post)),
-              _ => (0, store(KExprNode.BVar(0))),
-            },
-        },
-      0 =>
-        match is_pred {
-          1 =>
-            match u32_less_than(spine_len, 1) {
-              1 => (0, store(KExprNode.BVar(0))),
-              0 =>
-                let a0_w = whnf(list_lookup(spine, 0), types, top, addrs);
-                match try_extract_nat(a0_w, addrs) {
-                  (1, na) =>
-                    let post = list_drop(spine, 1);
-                    -- Normalize: dec at a limb boundary leaves a trailing zero
-                    -- limb, and a non-canonical Lit poisons every downstream
-                    -- literal comparison and ctor-exposure countdown.
-                    (1, apply_spine(mk_nat_lit(klimbs_normalize(klimbs_dec(na))), post)),
-                  _ => (0, store(KExprNode.BVar(0))),
-                },
-            },
-          0 => try_nat_binop_dispatch(head_addr, spine, spine_len, types, top, addrs),
-        },
-    }
-  }
-
-  -- Cold-extracted binop arm (mirror [[reference_aiur_hot_cold_split]]).
-  -- Binop dispatch is the widest arm of `try_nat_dispatch` (2× whnf + 2×
-  -- try_extract_nat + try_nat_binop_addr + apply_spine), so it pays
-  -- max-arm-width on every Nat.succ/Nat.pred row when inlined. Factored
-  -- here so its width only charges the rows that actually dispatch a
-  -- binop.
-  fn try_nat_binop_dispatch(head_addr: Addr, spine: List‹KExpr›, spine_len: G,
-                             types: List‹KExpr›, top: List‹&KConstantInfo›,
-                             addrs: List‹Addr›) -> (G, KExpr) {
-    match u32_less_than(spine_len, 2) {
-      1 => (0, store(KExprNode.BVar(0))),
-      0 =>
-        let a0_w = whnf(list_lookup(spine, 0), types, top, addrs);
-        let a1_w = whnf(list_lookup(spine, 1), types, top, addrs);
-        let pa = try_extract_nat(a0_w, addrs);
-        let pb = try_extract_nat(a1_w, addrs);
-        match pa {
-          (1, na) =>
-            match pb {
-              (1, nb) =>
-                match try_nat_binop_addr(head_addr, na, nb, addrs) {
-                  (1, result) =>
-                    let post = list_drop(spine, 2);
-                    (1, apply_spine(result, post)),
-                  (0, _) => (0, store(KExprNode.BVar(0))),
-                },
-              _ => (0, store(KExprNode.BVar(0))),
-            },
-          _ =>
-            -- Symbolic base: route to the cold offset-stuck check
-            -- (separate circuit so its width only taxes actual
-            -- symbolic-base events, not every literal binop row).
-            match pb {
-              (1, nb) =>
-                try_nat_offset_dispatch(head_addr, a0_w, nb, spine, addrs),
-              _ => (0, store(KExprNode.BVar(0))),
-            },
-        },
-    }
-  }
-
-  -- Cold path of try_nat_dispatch: a binary Nat op whose whnf'd base is
-  -- symbolic and whose second arg is `Lit nb`. For `Nat.add` (any nb) and
-  -- `Nat.div`/`Nat.mod` (nb >= 2) the term is irreducible: return verdict
-  -- 2 = "already stuck in compact offset form" so whnf keeps it instead of
-  -- delta-unfolding into a succ^nb tower / the division algorithm
-  -- (`x >>> k` = k nested `Nat.div _ 2`). Pairs with offset-aware def-eq.
-  fn try_nat_offset_dispatch(head_addr: Addr, a0_w: KExpr, nb: KLimbs,
-                             spine: List‹KExpr›, addrs: List‹Addr›) -> (G, KExpr) {
-    let is_add = address_eq(head_addr, nat_add_addr());
-    let is_divmod = address_eq(head_addr, nat_div_addr())
-      + address_eq(head_addr, nat_mod_addr());
-    let eligible =
-      is_add + is_divmod * (1 - klimbs_is_zero(nb))
-        * (1 - klimbs_is_zero(klimbs_dec(nb)));
-    match eligible {
-      0 => (0, store(KExprNode.BVar(0))),
-      _ =>
-        let post = list_drop(spine, 2);
-        -- `Nat.add` keeps the canonical add-offset shape (shared with the
-        -- linear-rec collapse). Div/mod MUST keep their own head: routing
-        -- them through the add builder rewrote `x / n` into `x + n` —
-        -- wrong value — corrupting offset-aware def-eq (unsound equalities
-        -- between /- and +-derived forms) and sending genuinely equal
-        -- `x >>> k` comparisons into full delta-unfolds of the division
-        -- algorithm on symbolic args.
-        match is_add {
-          1 =>
-            match mk_nat_offset_stuck(a0_w, nb, post, addrs) {
-              (1, stuck) => (2, stuck),
-              (0, _) => (0, store(KExprNode.BVar(0))),
-            },
-          0 =>
-            match mk_nat_binop_stuck(head_addr, a0_w, nb, post, addrs) {
-              (1, stuck) => (2, stuck),
-              (0, _) => (0, store(KExprNode.BVar(0))),
-            },
-        },
-    }
-  }
-
-  -- Rebuild a stuck binary Nat op `op base (Lit n)` applied to `post`,
-  -- preserving the op's own head (div stays div, mod stays mod). The
-  -- add-offset shape has its own builder (`mk_nat_offset_stuck`, shared
-  -- with the linear-rec collapse); this is the non-add sibling.
-  fn mk_nat_binop_stuck(op_addr: Addr, base_w: KExpr, n: KLimbs, post: List‹KExpr›,
-                        addrs: List‹Addr›) -> (G, KExpr) {
-    match find_addr_idx_safe(op_addr, addrs, 0) {
-      (0, _) => (0, store(KExprNode.BVar(0))),
-      (1, op_idx) =>
-        let op_const = store(KExprNode.Const(op_idx, store(ListNode.Nil)));
-        let stuck = store(KExprNode.App(
-          store(KExprNode.App(op_const, base_w)),
-          mk_nat_lit(n)));
-        (1, apply_spine(stuck, post)),
-    }
-  }
-
-  -- Dispatch a Nat binary op by head address. Bool result for beq/ble
-  -- wraps via Bool.true / Bool.false ctors (mk_bool).
-  fn try_nat_binop_addr(head_addr: Addr, a: KLimbs, b: KLimbs,
-                        addrs: List‹Addr›) -> (G, KExpr) {
-    match address_eq(head_addr, nat_add_addr()) {
-      1 => (1, mk_nat_lit(klimbs_normalize(klimbs_add(a, b)))),
-      0 =>
-        match address_eq(head_addr, nat_sub_addr()) {
-          1 => (1, mk_nat_lit(klimbs_normalize(klimbs_sub(a, b)))),
-          0 =>
-            match address_eq(head_addr, nat_mul_addr()) {
-              1 => (1, mk_nat_lit(klimbs_normalize(klimbs_mul(a, b)))),
-              0 =>
-                match address_eq(head_addr, nat_div_addr()) {
-                  1 => (1, mk_nat_lit(klimbs_normalize(klimbs_div(a, b)))),
-                  0 =>
-                    match address_eq(head_addr, nat_mod_addr()) {
-                      1 => (1, mk_nat_lit(klimbs_normalize(klimbs_mod(a, b)))),
-                      0 =>
-                        match address_eq(head_addr, nat_gcd_addr()) {
-                          1 => (1, mk_nat_lit(klimbs_normalize(klimbs_gcd(a, b)))),
-                          0 =>
-                            match address_eq(head_addr, nat_pow_addr()) {
-                              1 => (1, mk_nat_lit(klimbs_normalize(klimbs_pow(a, b)))),
-                              0 =>
-                                match address_eq(head_addr, nat_land_addr()) {
-                                  1 => (1, mk_nat_lit(klimbs_normalize(klimbs_land(a, b)))),
-                                  0 =>
-                                    match address_eq(head_addr, nat_lor_addr()) {
-                                      1 => (1, mk_nat_lit(klimbs_normalize(klimbs_lor(a, b)))),
-                                      0 =>
-                                        match address_eq(head_addr, nat_xor_addr()) {
-                                          1 => (1, mk_nat_lit(klimbs_normalize(klimbs_xor_op(a, b)))),
-                                          0 =>
-                                            match address_eq(head_addr, nat_shift_left_addr()) {
-                                              1 => (1, mk_nat_lit(klimbs_normalize(klimbs_shl(a, b)))),
-                                              0 =>
-                                                match address_eq(head_addr, nat_shift_right_addr()) {
-                                                  1 => (1, mk_nat_lit(klimbs_normalize(klimbs_shr(a, b)))),
-                                                  0 =>
-                                            match address_eq(head_addr, nat_beq_addr()) {
-                                              1 => (1, mk_bool(klimbs_eq(a, b), addrs)),
-                                              0 =>
-                                                match address_eq(head_addr, nat_ble_addr()) {
-                                                  1 => (1, mk_bool(klimbs_le(a, b), addrs)),
-                                                  0 => (0, store(KExprNode.BVar(0))),
-                                                },
-                                            },
-                                        },
-                                    },
-                                },
-                            },
-                        },
-                    },
-                },
-            },
-        },
-        },
-        },
-    }
-  }
-
-  -- Encode a boolean as `Const(Bool.true)` / `Const(Bool.false)` when
-  -- those ctors are present in addrs. Falls back to `Lit(Nat(0|1))`
-  -- when not (e.g., kernel const list lacks Bool — should not happen
-  -- in practice for typed beq/ble dispatch).
-  fn mk_bool(g: G, addrs: List‹Addr›) -> KExpr {
-    let target = match g {
-      0 => bool_false_addr(),
-      _ => bool_true_addr(),
-    };
-    let pair = find_addr_idx_safe(target, addrs, 0);
-    match pair {
-      (1, idx) => store(KExprNode.Const(idx, store(ListNode.Nil))),
-      (0, _) =>
-        match g {
-          0 => store(KExprNode.Lit(KLiteral.Nat(store(ListNode.Nil)))),
-          _ =>
-            store(KExprNode.Lit(KLiteral.Nat(
-              store(ListNode.Cons([1u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], store(ListNode.Nil)))))),
-        },
-    }
-  }
-
-  -- Single-limb KLimbs to G value (low 4 bytes). Used for bitvec width
-  -- where width ≤ 2^24 fits in 24 bits. Returns 0 for empty KLimbs.
-  fn klimbs_lo_g(n: KLimbs) -> G {
-    match load(n) {
-      ListNode.Nil => 0,
-      ListNode.Cons(limb, _) =>
-        let [b0, b1, b2, b3, _, _, _, _] = limb;
-        to_field(b0) + 256*to_field(b1) + 65536*to_field(b2) + 16777216*to_field(b3),
-    }
-  }
-
-  -- Mirror: src/ix/kernel/whnf.rs:2546-2579 fn try_reduce_bitvec_to_nat.
-  -- `BitVec.toNat width (BitVec.ofNat width' n)` → `Lit(Nat (n mod 2^width))`.
-  -- Width must be ≤ 2^24 to bound klimbs_pow cost.
-  fn try_reduce_bit_vec_to_nat(spine: List‹KExpr›, types: List‹KExpr›,
-                                top: List‹&KConstantInfo›,
-                                addrs: List‹Addr›) -> (G, KExpr) {
-    match u32_less_than(list_length(spine), 2) {
-      1 => (0, store(KExprNode.BVar(0))),
-      0 =>
-        let width_e = list_lookup(spine, 0);
-        let val_e = list_lookup(spine, 1);
-        let val_w = whnf(val_e, types, top, addrs);
-        -- Mirror: src/ix/kernel/whnf.rs:2581-2602 bitvec_of_nat_args.
-        -- Accepts both `BitVec.ofNat(W, N)` and `OfNat.ofNat(BitVec W, N)`.
-        let pair = bitvec_of_nat_args(val_w, addrs);
-        match pair {
-          (0, _, _) => (0, store(KExprNode.BVar(0))),
-          (1, val_width, n_e) =>
-            let n_w = whnf(n_e, types, top, addrs);
-            let np = try_extract_nat(n_w, addrs);
-            match np {
-              (0, _) => (0, store(KExprNode.BVar(0))),
-              (1, n_klimbs) =>
-                let width_w = whnf(val_width, types, top, addrs);
-                let wp = try_extract_nat(width_w, addrs);
-                match wp {
-                  (0, _) => (0, store(KExprNode.BVar(0))),
-                  (1, w_klimbs) =>
-                    let two = store(ListNode.Cons([2u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], store(ListNode.Nil)));
-                    let modulus = klimbs_pow(two, w_klimbs);
-                    let result = klimbs_mod(n_klimbs, modulus);
-                    (1, mk_nat_lit(result)),
-                },
-            },
-        },
-    }
-  }
-
-  -- Mirror: src/ix/kernel/whnf.rs:2581-2602 fn bitvec_of_nat_args.
-  -- Returns (1, width_e, n_e) if `e` is `BitVec.ofNat W N` or
-  -- `OfNat.ofNat (BitVec W) N _inst`. Else (0, _, _).
-  fn bitvec_of_nat_args(e: KExpr, addrs: List‹Addr›) -> (G, KExpr, KExpr) {
-    match collect_spine(e) {
-      (head, args) =>
-        match load(head) {
-          KExprNode.Const(idx, _) =>
-            let head_addr = list_lookup(addrs, idx);
-            match address_eq(head_addr, bit_vec_of_nat_addr()) {
-              1 =>
-                match list_length(args) - 2 {
-                  0 => (1, list_lookup(args, 0), list_lookup(args, 1)),
-                  _ => (0, store(KExprNode.BVar(0)), store(KExprNode.BVar(0))),
-                },
-              0 =>
-                let of_nat_addr = store([0x8fu8, 0xdcu8, 0x86u8, 0x9fu8, 0x7bu8, 0x7au8, 0xa2u8, 0xb7u8,
-                                   0xb5u8, 0x92u8, 0x9bu8, 0xa2u8, 0x42u8, 0xedu8, 0x89u8, 0x9cu8,
-                                   0xe2u8, 0xd7u8, 0xc5u8, 0xd4u8, 0x2du8, 0xf1u8, 0xd4u8, 0xe2u8,
-                                   0x39u8, 0x36u8, 0x90u8, 0xcfu8, 0xa8u8, 0x5eu8, 0x94u8, 0xd2u8]);
-                match address_eq(head_addr, of_nat_addr) {
-                  0 => (0, store(KExprNode.BVar(0)), store(KExprNode.BVar(0))),
-                  1 =>
-                    match u32_less_than(list_length(args), 2) {
-                      1 => (0, store(KExprNode.BVar(0)), store(KExprNode.BVar(0))),
-                      0 =>
-                        let ty_arg = list_lookup(args, 0);
-                        match collect_spine(ty_arg) {
-                          (ty_head, ty_args) =>
-                            match load(ty_head) {
-                              KExprNode.Const(ty_idx, _) =>
-                                let ty_addr = list_lookup(addrs, ty_idx);
-                                match address_eq(ty_addr, bit_vec_addr()) {
-                                  0 => (0, store(KExprNode.BVar(0)), store(KExprNode.BVar(0))),
-                                  1 =>
-                                    match list_length(ty_args) - 1 {
-                                      0 => (1, list_lookup(ty_args, 0), list_lookup(args, 1)),
-                                      _ => (0, store(KExprNode.BVar(0)), store(KExprNode.BVar(0))),
-                                    },
-                                },
-                              _ => (0, store(KExprNode.BVar(0)), store(KExprNode.BVar(0))),
-                            },
-                        },
-                    },
-                },
-            },
-          _ => (0, store(KExprNode.BVar(0)), store(KExprNode.BVar(0))),
-        },
-    }
-  }
-
-  -- Mirror: src/ix/kernel/whnf.rs:2465-2506 fn try_reduce_bitvec_ult.
-  -- `BitVec.ult width lhs rhs` → `Bool.true/false`. Both sides converted
-  -- to nat via bit_vec_to_nat, then compared with `<` (= Nat.ble (lhs+1) rhs).
-  fn try_reduce_bit_vec_ult(spine: List‹KExpr›, types: List‹KExpr›,
-                             top: List‹&KConstantInfo›,
-                             addrs: List‹Addr›) -> (G, KExpr) {
-    match u32_less_than(list_length(spine), 3) {
-      1 => (0, store(KExprNode.BVar(0))),
-      0 =>
-        let width_e = list_lookup(spine, 0);
-        let lhs_e = list_lookup(spine, 1);
-        let rhs_e = list_lookup(spine, 2);
-        -- Build BitVec.toNat width lhs / rhs and reduce.
-        let lhs_pair = bv_to_nat_via(width_e, lhs_e, types, top, addrs);
-        let rhs_pair = bv_to_nat_via(width_e, rhs_e, types, top, addrs);
-        match lhs_pair {
-          (0, _) => (0, store(KExprNode.BVar(0))),
-          (1, lhs_n) =>
-            match rhs_pair {
-              (0, _) => (0, store(KExprNode.BVar(0))),
-              (1, rhs_n) =>
-                -- lhs < rhs iff klimbs_le(lhs+1, rhs) iff !klimbs_le(rhs, lhs)
-                let r = 1 - klimbs_le(rhs_n, lhs_n);
-                (1, mk_bool(r, addrs)),
-            },
-        },
-    }
-  }
-
-  -- Helper: invoke bit_vec_to_nat reduction on (width, val) pair, return
-  -- extracted nat KLimbs. Returns (1, klimbs) or (0, _).
-  fn bv_to_nat_via(width_e: KExpr, val_e: KExpr, types: List‹KExpr›,
-                    top: List‹&KConstantInfo›,
-                    addrs: List‹Addr›) -> (G, KLimbs) {
-    let spine = store(ListNode.Cons(width_e,
-      store(ListNode.Cons(val_e, store(ListNode.Nil)))));
-    let r = try_reduce_bit_vec_to_nat(spine, types, top, addrs);
-    match r {
-      (0, _) => (0, store(ListNode.Nil)),
-      (1, lit_e) =>
-        match load(lit_e) {
-          KExprNode.Lit(lit) =>
-            match lit {
-              KLiteral.Nat(klimbs) => (1, klimbs),
-              _ => (0, store(ListNode.Nil)),
-            },
-          _ => (0, store(ListNode.Nil)),
-        },
-    }
-  }
-
-  -- Top-level bitvec dispatch: routes head_addr to the right reduction.
-  fn try_bitvec_dispatch(head_addr: Addr, spine: List‹KExpr›,
-                          types: List‹KExpr›,
-                          top: List‹&KConstantInfo›,
-                          addrs: List‹Addr›) -> (G, KExpr) {
-    match address_eq(head_addr, bit_vec_to_nat_addr()) {
-      1 => try_reduce_bit_vec_to_nat(spine, types, top, addrs),
-      0 =>
-        match address_eq(head_addr, bit_vec_ult_addr()) {
-          1 => try_reduce_bit_vec_ult(spine, types, top, addrs),
-          0 =>
-            -- decide (LT.lt BitVec width a b) → bitvec_ult.
-            -- Mirror: src/ix/kernel/whnf.rs:2455-2460.
-            match address_eq(head_addr, decidable_decide_addr()) {
-              1 => try_reduce_decide_bitvec_lt(spine, types, top, addrs),
-              0 => (0, store(KExprNode.BVar(0))),
-            },
-        },
-    }
-  }
-
-  -- `decide (LT.lt BitVec a b) inst` → if LT.lt's type arg is BitVec, reduce
-  -- via bit_vec_ult. Mirror: src/ix/kernel/whnf.rs:2508-2529 fn try_reduce_bitvec_lt_prop.
-  fn try_reduce_decide_bitvec_lt(spine: List‹KExpr›, types: List‹KExpr›,
-                                  top: List‹&KConstantInfo›,
-                                  addrs: List‹Addr›) -> (G, KExpr) {
-    match u32_less_than(list_length(spine), 2) {
-      1 => (0, store(KExprNode.BVar(0))),
-      0 =>
-        let prop = list_lookup(spine, 0);
-        match collect_spine(prop) {
-          (lt_head, lt_args) =>
-            match load(lt_head) {
-              KExprNode.Const(lt_idx, _) =>
-                let lt_addr = list_lookup(addrs, lt_idx);
-                match address_eq(lt_addr, lt_lt_addr()) {
-                  0 => (0, store(KExprNode.BVar(0))),
-                  1 =>
-                    match u32_less_than(list_length(lt_args), 4) {
-                      1 => (0, store(KExprNode.BVar(0))),
-                      0 =>
-                        let ty_arg = list_lookup(lt_args, 0);
-                        match collect_spine(ty_arg) {
-                          (ty_head, ty_args) =>
-                            match load(ty_head) {
-                              KExprNode.Const(ty_idx, _) =>
-                                let ty_addr = list_lookup(addrs, ty_idx);
-                                match address_eq(ty_addr, bit_vec_addr()) {
-                                  0 => (0, store(KExprNode.BVar(0))),
-                                  1 =>
-                                    match u32_less_than(list_length(ty_args), 1) {
-                                      1 => (0, store(KExprNode.BVar(0))),
-                                      0 =>
-                                        let width = list_lookup(ty_args, 0);
-                                        let lhs = list_lookup(lt_args, 2);
-                                        let rhs = list_lookup(lt_args, 3);
-                                        let inner_spine = store(ListNode.Cons(width,
-                                          store(ListNode.Cons(lhs,
-                                            store(ListNode.Cons(rhs, store(ListNode.Nil)))))));
-                                        try_reduce_bit_vec_ult(inner_spine, types, top, addrs),
-                                    },
-                                },
-                              _ => (0, store(KExprNode.BVar(0))),
-                            },
-                        },
-                    },
-                },
-              _ => (0, store(KExprNode.BVar(0))),
-            },
-        },
-    }
-  }
-
-  -- Mirror: src/ix/kernel/whnf.rs:2637-2755 fn try_reduce_native.
-  -- Handles compiler-emitted Nat/Bool reductions:
-  --   • `Lean.reduceBool c` / `Lean.reduceNat c`: unfold + accept ctor/lit.
-  --   • `System.Platform.numBits` (no args) → `Lit(Nat 64)`.
-  --   • `Subtype.val (System.Platform.getNumBits ())` → `Lit(Nat 64)`.
-  --   • `SizeOf.sizeOf Unit/PUnit ...` → `Lit(Nat 1)`.
-  --   • `PUnit.SizeOf.1 ...` → `Lit(Nat 1)`.
-  fn try_reduce_native(head_addr: Addr, spine: List‹KExpr›,
-                       types: List‹KExpr›,
-                       top: List‹&KConstantInfo›,
-                       addrs: List‹Addr›) -> (G, KExpr) {
-    -- Nullary System.Platform.numBits
-    match address_eq(head_addr, system_platform_num_bits_addr()) {
-      1 => (1, mk_nat_literal_64()),
-      0 =>
-        -- subtype_val (... getNumBits ()): 3 args, args[2] is `getNumBits ()`.
-        match address_eq(head_addr, subtype_val_addr()) {
-          1 => try_reduce_subtype_val(spine, addrs),
-          0 =>
-            -- size_of_size_of Unit/PUnit ...: 3 args, first is type.
-            match address_eq(head_addr, size_of_size_of_addr()) {
-              1 => try_reduce_size_of_unit(spine, addrs),
-              0 =>
-                -- PUnit's stored sizeOf instance.
-                match address_eq(head_addr, punit_size_of_1_addr()) {
-                  1 => (1, mk_nat_one()),
-                  0 =>
-                    let is_rb = address_eq(head_addr, reduce_bool_addr());
-                    let is_rn = address_eq(head_addr, reduce_nat_addr());
-                    match is_rb + is_rn {
-                      0 => (0, store(KExprNode.BVar(0))),
-                      _ =>
-                        match u32_less_than(list_length(spine), 1) {
-                          1 => (0, store(KExprNode.BVar(0))),
-                          0 =>
-                            let arg = list_lookup(spine, 0);
-                            let result = whnf(arg, types, top, addrs);
-                            match is_rb {
-                              1 => check_native_bool(result, addrs),
-                              0 => check_native_nat(result),
-                            },
-                        },
-                    },
-                },
-            },
-        },
-    }
-  }
-
-  fn mk_nat_literal_64() -> KExpr {
-    let limbs = store(ListNode.Cons([64u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], store(ListNode.Nil)));
-    store(KExprNode.Lit(KLiteral.Nat(limbs)))
-  }
-
-  fn mk_nat_one() -> KExpr {
-    let limbs = store(ListNode.Cons([1u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], store(ListNode.Nil)));
-    store(KExprNode.Lit(KLiteral.Nat(limbs)))
-  }
-
-  -- Subtype.val A P (System.Platform.getNumBits ()) → 64.
-  -- Spine: [A, P, val_arg]. If val_arg's spine head = getNumBits, return 64.
-  fn try_reduce_subtype_val(spine: List‹KExpr›,
-                            addrs: List‹Addr›) -> (G, KExpr) {
-    match u32_less_than(list_length(spine), 3) {
-      1 => (0, store(KExprNode.BVar(0))),
-      0 =>
-        let val_arg = list_lookup(spine, 2);
-        match collect_spine(val_arg) {
-          (head, _) =>
-            match load(head) {
-              KExprNode.Const(idx, _) =>
-                let head_addr = list_lookup(addrs, idx);
-                match address_eq(head_addr, system_platform_get_num_bits_addr()) {
-                  1 => (1, mk_nat_literal_64()),
-                  0 => (0, store(KExprNode.BVar(0))),
-                },
-              _ => (0, store(KExprNode.BVar(0))),
-            },
-        },
-    }
-  }
-
-  -- size_of_size_of Unit/PUnit ... → 1. First arg is the type.
-  fn try_reduce_size_of_unit(spine: List‹KExpr›,
-                             addrs: List‹Addr›) -> (G, KExpr) {
-    match u32_less_than(list_length(spine), 1) {
-      1 => (0, store(KExprNode.BVar(0))),
-      0 =>
-        let ty_arg = list_lookup(spine, 0);
-        match collect_spine(ty_arg) {
-          (head, _) =>
-            match load(head) {
-              KExprNode.Const(idx, _) =>
-                let head_addr = list_lookup(addrs, idx);
-                let is_unit = address_eq(head_addr, unit_addr());
-                let is_punit = address_eq(head_addr, punit_addr());
-                match is_unit + is_punit {
-                  0 => (0, store(KExprNode.BVar(0))),
-                  _ => (1, mk_nat_one()),
-                },
-              _ => (0, store(KExprNode.BVar(0))),
-            },
-        },
-    }
-  }
-
-  -- For reduce_bool: result must be Const(bool_true|bool_false).
-  fn check_native_bool(e: KExpr, addrs: List‹Addr›) -> (G, KExpr) {
-    match load(e) {
-      KExprNode.Const(idx, _) =>
-        let head_addr = list_lookup(addrs, idx);
-        let is_t = address_eq(head_addr, bool_true_addr());
-        let is_f = address_eq(head_addr, bool_false_addr());
-        match is_t + is_f {
-          0 => (0, store(KExprNode.BVar(0))),
-          _ => (1, e),
-        },
-      _ => (0, store(KExprNode.BVar(0))),
-    }
-  }
-
-  -- For reduce_nat: result must be Lit(Nat).
-  fn check_native_nat(e: KExpr) -> (G, KExpr) {
-    match load(e) {
-      KExprNode.Lit(lit) =>
-        match lit {
-          KLiteral.Nat(_) => (1, e),
-          _ => (0, store(KExprNode.BVar(0))),
-        },
-      _ => (0, store(KExprNode.BVar(0))),
-    }
-  }
-
-  -- Mirror: src/ix/kernel/whnf.rs:2173-2329 fn try_reduce_decidable.
-  -- Handles `Nat.decLe`/`decEq`/`decLt`. Constructs `Decidable.isTrue/isFalse`
-  -- proof terms with `Eq.refl Bool Bool.true/false` witnesses.
-  --
-  -- For decLt: rewrites to `decLe (n+1) m` and recurses through whnf.
-  -- For decLe / decEq: extracts n, m as Nat lits; computes verdict; builds
-  -- proof term using compiler-emitted helper fns.
-  --
-  -- Prop extraction: invokes `k_infer` on the call expression's spine head
-  -- + spine to recover the `Decidable prop` type. `prop` is the type's
-  -- first arg. Requires `types` to be the local context so k_infer is
-  -- valid under binders.
-  fn try_reduce_decidable(head_addr: Addr, head_idx: G,
-                          head_lvls: List‹KLevel›,
-                          spine: List‹KExpr›,
-                          types: List‹KExpr›,
-                          top: List‹&KConstantInfo›,
-                          addrs: List‹Addr›) -> (G, KExpr) {
-    let is_dec_le = address_eq(head_addr, nat_dec_le_addr());
-    let is_dec_eq = address_eq(head_addr, nat_dec_eq_addr());
-    let is_dec_lt = address_eq(head_addr, nat_dec_lt_addr());
-    let is_int_dec_le = address_eq(head_addr, int_dec_le_addr());
-    let is_int_dec_eq = address_eq(head_addr, int_dec_eq_addr());
-    let is_int_dec_lt = address_eq(head_addr, int_dec_lt_addr());
-    match is_int_dec_le + is_int_dec_eq + is_int_dec_lt {
-      1 => try_normalize_int_decidable(head_idx, head_lvls, spine, types, top, addrs),
-      _ =>
-        match is_dec_le + is_dec_eq + is_dec_lt {
-          0 => (0, store(KExprNode.BVar(0))),
-          _ =>
-            match u32_less_than(list_length(spine), 2) {
-              1 => (0, store(KExprNode.BVar(0))),
-              0 => decidable_dispatch(is_dec_le, is_dec_eq, is_dec_lt, head_idx, head_lvls,
-                                       spine, types, top, addrs),
-            },
-        },
-    }
-  }
-
-  -- Try-match `App(Const(int_of_nat | int_neg_succ), Lit(Nat _))`. Returns
-  -- `(found, sign, limbs)` where sign=0 for nonneg (Int.ofNat), 1 for
-  -- Int.negSucc. Mirror: src/ix/kernel/whnf.rs::extract_int_lit.
-  fn try_extract_int(e: KExpr, addrs: List‹Addr›) -> (G, G, KLimbs) {
-    match load(e) {
-      KExprNode.App(f, a) =>
-        match load(f) {
-          KExprNode.Const(idx, _) =>
-            let head_addr = list_lookup(addrs, idx);
-            let is_ofnat = address_eq(head_addr, int_of_nat_addr());
-            let is_negsucc = address_eq(head_addr, int_neg_succ_addr());
-            match is_ofnat + is_negsucc {
-              0 => (0, 0, store(ListNode.Nil)),
-              _ =>
-                match load(a) {
-                  KExprNode.Lit(lit) =>
-                    match lit {
-                      KLiteral.Nat(limbs) => (1, is_negsucc, limbs),
-                      _ => (0, 0, store(ListNode.Nil)),
-                    },
-                  _ => (0, 0, store(ListNode.Nil)),
-                },
-            },
-          _ => (0, 0, store(ListNode.Nil)),
-        },
-      _ => (0, 0, store(ListNode.Nil)),
-    }
-  }
-
-  -- Build canonical `App(Const(int_of_nat | int_neg_succ), Lit(Nat n))`.
-  fn intern_int_lit(sign: G, limbs: KLimbs, addrs: List‹Addr›) -> (G, KExpr) {
-    let target = match sign {
-      0 => int_of_nat_addr(),
-      _ => int_neg_succ_addr(),
-    };
-    match find_addr_idx_safe(target, addrs, 0) {
-      (1, idx) =>
-        let head = store(KExprNode.Const(idx, store(ListNode.Nil)));
-        (1, store(KExprNode.App(head, mk_nat_lit(limbs)))),
-      (0, _) => (0, store(KExprNode.BVar(0))),
-    }
-  }
-
-  -- Mirror: src/ix/kernel/whnf.rs:2331-2370 fn try_normalize_int_decidable.
-  -- For Int.decEq/decLe/decLt: whnf both args, extract Int literals,
-  -- rebuild canonical form `App(Const(int_dec_*), int_of_nat n, int_neg_succ k, ...)`.
-  -- Bails if both args already canonical (no normalization needed).
-  fn try_normalize_int_decidable(head_idx: G, head_lvls: List‹KLevel›,
-                                  spine: List‹KExpr›, types: List‹KExpr›,
-                                  top: List‹&KConstantInfo›,
-                                  addrs: List‹Addr›) -> (G, KExpr) {
-    match u32_less_than(list_length(spine), 2) {
-      1 => (0, store(KExprNode.BVar(0))),
-      0 =>
-        let a0 = list_lookup(spine, 0);
-        let a1 = list_lookup(spine, 1);
-        match try_extract_int(a0, addrs) {
-          (1, _, _) =>
-            match try_extract_int(a1, addrs) {
-              -- Both already canonical Int lits — no normalization needed.
-              (1, _, _) => (0, store(KExprNode.BVar(0))),
-              _ => normalize_int_dec_rebuild(head_idx, head_lvls, spine, a0, a1, types, top, addrs),
-            },
-          _ => normalize_int_dec_rebuild(head_idx, head_lvls, spine, a0, a1, types, top, addrs),
-        },
-    }
-  }
-
-  fn normalize_int_dec_rebuild(head_idx: G, head_lvls: List‹KLevel›,
-                                spine: List‹KExpr›, a0: KExpr, a1: KExpr,
-                                types: List‹KExpr›, top: List‹&KConstantInfo›,
-                                addrs: List‹Addr›) -> (G, KExpr) {
-    let wa = whnf(a0, types, top, addrs);
-    let wb = whnf(a1, types, top, addrs);
-    match try_extract_int(wa, addrs) {
-      (1, sa, na) =>
-        match try_extract_int(wb, addrs) {
-          (1, sb, nb) =>
-            match intern_int_lit(sa, na, addrs) {
-              (1, a_e) =>
-                match intern_int_lit(sb, nb, addrs) {
-                  (1, b_e) =>
-                    let head = store(KExprNode.Const(head_idx, head_lvls));
-                    let r1 = store(KExprNode.App(head, a_e));
-                    let r2 = store(KExprNode.App(r1, b_e));
-                    let post = list_drop(spine, 2);
-                    (1, apply_spine(r2, post)),
-                  _ => (0, store(KExprNode.BVar(0))),
-                },
-              _ => (0, store(KExprNode.BVar(0))),
-            },
-          _ => (0, store(KExprNode.BVar(0))),
-        },
-      _ => (0, store(KExprNode.BVar(0))),
-    }
-  }
-
-  fn decidable_dispatch(is_dec_le: G, is_dec_eq: G, is_dec_lt: G,
-                         head_idx: G, head_lvls: List‹KLevel›,
-                         spine: List‹KExpr›, types: List‹KExpr›,
-                         top: List‹&KConstantInfo›,
-                         addrs: List‹Addr›) -> (G, KExpr) {
-    -- decLt n m → decLe (n+1) m: rewrite spine.
-    match is_dec_lt {
-      1 =>
-        let n_e = list_lookup(spine, 0);
-        let m_e = list_lookup(spine, 1);
-        let n_w = whnf(n_e, types, top, addrs);
-        let np = try_extract_nat(n_w, addrs);
-        match np {
-          (0, _) => (0, store(KExprNode.BVar(0))),
-          (1, n_klimbs) =>
-            let succ_n = klimbs_succ(n_klimbs);
-            let succ_n_lit = mk_nat_lit(succ_n);
-            let dec_le_const = store(KExprNode.Const(0, store(ListNode.Nil)));
-            -- Find dec_le_idx via address.
-            let pair = find_addr_idx_safe(nat_dec_le_addr(), addrs, 0);
-            match pair {
-              (0, _) => (0, store(KExprNode.BVar(0))),
-              (1, dec_le_idx) =>
-                let head = store(KExprNode.Const(dec_le_idx, store(ListNode.Nil)));
-                let app1 = store(KExprNode.App(head, succ_n_lit));
-                let app2 = store(KExprNode.App(app1, m_e));
-                let post = list_drop(spine, 2);
-                let result = apply_spine(app2, post);
-                (1, result),
-            },
-        },
-      0 =>
-        decidable_dispatch_le_eq(is_dec_le, is_dec_eq, head_idx, head_lvls,
-                                 spine, types, top, addrs),
-    }
-  }
-
-  fn decidable_dispatch_le_eq(is_dec_le: G, is_dec_eq: G,
-                              head_idx: G, head_lvls: List‹KLevel›,
-                              spine: List‹KExpr›, types: List‹KExpr›,
-                              top: List‹&KConstantInfo›,
-                              addrs: List‹Addr›) -> (G, KExpr) {
-    let n_e = list_lookup(spine, 0);
-    let m_e = list_lookup(spine, 1);
-    let n_w = whnf(n_e, types, top, addrs);
-    let m_w = whnf(m_e, types, top, addrs);
-    let np = try_extract_nat(n_w, addrs);
-    let mp = try_extract_nat(m_w, addrs);
-    match np {
-      (0, _) => (0, store(KExprNode.BVar(0))),
-      (1, n_kl) =>
-        match mp {
-          (0, _) => (0, store(KExprNode.BVar(0))),
-          (1, m_kl) =>
-            let verdict = match is_dec_le {
-              1 => klimbs_le(n_kl, m_kl),
-              0 => klimbs_eq(n_kl, m_kl),
-            };
-            decidable_build_proof(is_dec_le, is_dec_eq, verdict, n_e, m_e,
-                                  head_idx, head_lvls, spine, types, top, addrs),
-        },
-    }
-  }
-
-  -- Build Decidable.isTrue/isFalse proof term. Prop slot recovered via
-  -- k_infer over the original call expression in `decidable_finish`.
-  fn decidable_build_proof(is_dec_le: G, is_dec_eq: G, verdict: G,
-                           n_e: KExpr, m_e: KExpr,
-                           head_idx: G, head_lvls: List‹KLevel›,
-                           spine: List‹KExpr›,
-                           types: List‹KExpr›,
-                           top: List‹&KConstantInfo›,
-                           addrs: List‹Addr›) -> (G, KExpr) {
-    -- Build `Eq.refl.{1} Bool Bool.true_or_false`.
-    let eq_refl_pair = find_addr_idx_safe(eq_refl_addr(), addrs, 0);
-    match eq_refl_pair {
-      (0, _) => (0, store(KExprNode.BVar(0))),
-      (1, eq_refl_idx) =>
-        let bool_pair = find_addr_idx_safe(bool_type_addr(), addrs, 0);
-        match bool_pair {
-          (0, _) => (0, store(KExprNode.BVar(0))),
-          (1, bool_idx) =>
-            let bool_lit_pair = match verdict {
-              1 => find_addr_idx_safe(bool_true_addr(), addrs, 0),
-              0 => find_addr_idx_safe(bool_false_addr(), addrs, 0),
-            };
-            match bool_lit_pair {
-              (0, _) => (0, store(KExprNode.BVar(0))),
-              (1, bool_lit_idx) =>
-                let one_lvl = store(KLevelNode.Succ(store(KLevelNode.Zero)));
-                let lvls = store(ListNode.Cons(one_lvl, store(ListNode.Nil)));
-                let eq_refl_const = store(KExprNode.Const(eq_refl_idx, lvls));
-                let bool_const = store(KExprNode.Const(bool_idx, store(ListNode.Nil)));
-                let bool_lit_const = store(KExprNode.Const(bool_lit_idx, store(ListNode.Nil)));
-                let r1 = store(KExprNode.App(eq_refl_const, bool_const));
-                let refl_proof = store(KExprNode.App(r1, bool_lit_const));
-                -- proof_fn: nat_le_of_ble_eq_true / nat_eq_of_beq_eq_true /
-                -- nat_ne_of_beq_eq_false based on (is_dec_le, verdict).
-                let proof_fn_addr = match is_dec_le {
-                  1 =>
-                    match verdict {
-                      1 => nat_le_of_ble_eq_true_addr(),
-                      0 => nat_not_le_of_not_ble_eq_true_addr(),
-                    },
-                  0 =>
-                    match verdict {
-                      1 => nat_eq_of_beq_eq_true_addr(),
-                      0 => nat_ne_of_beq_eq_false_addr(),
-                    },
-                };
-                let proof_fn_pair = find_addr_idx_safe(proof_fn_addr, addrs, 0);
-                match proof_fn_pair {
-                  (0, _) => (0, store(KExprNode.BVar(0))),
-                  (1, proof_fn_idx) =>
-                    -- Bail decLe-false: needs Bool.noConfusion proof not yet
-                    -- exposed. Mirror Rust whnf.rs:2317-2322.
-                    let bail = is_dec_le * (1 - verdict);
-                    match bail {
-                      1 => (0, store(KExprNode.BVar(0))),
-                      0 =>
-                        let proof_const = store(KExprNode.Const(proof_fn_idx, store(ListNode.Nil)));
-                        let p1 = store(KExprNode.App(proof_const, n_e));
-                        let p2 = store(KExprNode.App(p1, m_e));
-                        let proof = store(KExprNode.App(p2, refl_proof));
-                        decidable_finish(verdict, proof, head_idx, head_lvls,
-                                          spine, types, top, addrs),
-                    },
-                },
-            },
-        },
-    }
-  }
-
-  fn decidable_finish(verdict: G, proof: KExpr, head_idx: G,
-                       head_lvls: List‹KLevel›, spine: List‹KExpr›,
-                       types: List‹KExpr›, top: List‹&KConstantInfo›,
-                       addrs: List‹Addr›) -> (G, KExpr) {
-    let dec_addr = match verdict {
-      1 => decidable_is_true_addr(),
-      0 => decidable_is_false_addr(),
-    };
-    let dec_pair = find_addr_idx_safe(dec_addr, addrs, 0);
-    match dec_pair {
-      (0, _) => (0, store(KExprNode.BVar(0))),
-      (1, dec_idx) =>
-        -- Reconstruct head Const + first 2 spine args, k_infer to get
-        -- `Decidable prop`, extract prop. Mirrors Rust producing the
-        -- elaborator-shaped `Decidable.isTrue (n ≤ m) ...` form.
-        let head_const = store(KExprNode.Const(head_idx, head_lvls));
-        let two_args = list_take(spine, 2);
-        let call_expr = apply_spine(head_const, two_args);
-        let call_ty = k_infer(call_expr, types, top, addrs);
-        let call_ty_w = whnf(call_ty, types, top, addrs);
-        match collect_spine(call_ty_w) {
-          (_, dec_args) =>
-            -- Guard against malformed inferred type. Rust returns
-            -- `Ok(None)` when the spine is empty; Aiur bails to (0, _)
-            -- so caller falls through to delta unfolding.
-            match u32_less_than(list_length(dec_args), 1) {
-              1 => (0, store(KExprNode.BVar(0))),
-              0 =>
-                let prop = list_lookup(dec_args, 0);
-                let dec_const = store(KExprNode.Const(dec_idx, store(ListNode.Nil)));
-                let r1 = store(KExprNode.App(dec_const, prop));
-                let r2 = store(KExprNode.App(r1, proof));
-                let post = list_drop(spine, 2);
-                (1, apply_spine(r2, post)),
-            },
-        },
-    }
-  }
-
-  -- Mirror: crates/kernel/src/whnf.rs fn try_reduce_string +
-  -- char_of_nat_expr.
-  --
-  -- Unary ops (`String.utf8ByteSize`, `String.back`, `String.legacy_back`,
-  -- `String.toByteArray`) require a single syntactic Lit(Str) arg. The
-  -- binary value ops (`String.append`, `String.decEq`) whnf both args
-  -- first (Rust `two_string_lit_args` / `whnf_prim_arg`), so nested
-  -- appends chain. `head` is the original Const expr, needed by the
-  -- decEq arm's `k_infer` prop recovery.
-  fn try_str_dispatch(head_addr: Addr, head: KExpr, spine: List‹KExpr›,
-                      types: List‹KExpr›, top: List‹&KConstantInfo›,
-                      addrs: List‹Addr›) -> (G, KExpr) {
-    let is_append = address_eq(head_addr, string_append_addr());
-    let is_dec_eq = address_eq(head_addr, string_dec_eq_addr());
-    let is_of_list = address_eq(head_addr, string_of_list_addr());
-    match is_of_list {
-      1 => try_str_of_list(spine, types, top, addrs),
-      0 =>
-        match is_append + is_dec_eq {
-          0 => try_str_dispatch_unary(head_addr, spine, addrs),
-          _ => try_str_binop(is_append, head, spine, types, top, addrs),
-        },
-    }
-  }
-
-  -- The pre-existing single-Lit(Str)-arg ops, unchanged.
-  fn try_str_dispatch_unary(head_addr: Addr, spine: List‹KExpr›,
-                            addrs: List‹Addr›) -> (G, KExpr) {
-    let spine_len = list_length(spine);
-    let lt1 = u32_less_than(spine_len, 1);
-    match lt1 {
-      1 => (0, store(KExprNode.BVar(0))),
-      0 =>
-        let a0 = list_lookup(spine, 0);
-        match load(a0) {
-          KExprNode.Lit(lit) =>
-            match lit {
-              KLiteral.Str(bs) =>
-                match address_eq(head_addr, string_utf8_byte_size_addr()) {
-                  1 =>
-                    let len = list_length_u64(bs);
-                    let limbs = store(ListNode.Cons(len, store(ListNode.Nil)));
-                    (1, store(KExprNode.Lit(KLiteral.Nat(limbs)))),
-                  0 =>
-                    match address_eq(head_addr, string_to_byte_array_addr()) {
-                      1 => try_str_to_byte_array(bs, addrs),
-                      0 =>
-                        let is_back = address_eq(head_addr, string_back_addr());
-                        let is_legacy = address_eq(head_addr, string_legacy_back_addr());
-                        match is_back + is_legacy {
-                          0 => (0, store(KExprNode.BVar(0))),
-                          _ => try_str_back(bs, addrs),
-                        },
-                    },
-                },
-              _ => (0, store(KExprNode.BVar(0))),
-            },
-          _ => (0, store(KExprNode.BVar(0))),
-        },
-    }
-  }
-
-  -- Mirror: crates/kernel/src/whnf.rs `String.append`/`String.decEq` arms
-  -- of try_reduce_string. Exactly-two-arg applications only (Rust bails
-  -- on `args.len() != 2`); both args whnf'd, both must land on Lit(Str).
-  fn try_str_binop(is_append: G, head: KExpr, spine: List‹KExpr›,
-                   types: List‹KExpr›, top: List‹&KConstantInfo›,
-                   addrs: List‹Addr›) -> (G, KExpr) {
-    match list_length(spine) {
-      2 =>
-        let a_w = whnf(list_lookup(spine, 0), types, top, addrs);
-        match load(a_w) {
-          KExprNode.Lit(la) =>
-            match la {
-              KLiteral.Str(sa) =>
-                let b_w = whnf(list_lookup(spine, 1), types, top, addrs);
-                match load(b_w) {
-                  KExprNode.Lit(lb) =>
-                    match lb {
-                      KLiteral.Str(sb) =>
-                        match is_append {
-                          1 =>
-                            -- Concatenated literal: UTF-8 of the join is
-                            -- the joined byte streams.
-                            let joined = list_concat(sa, sb);
-                            (1, store(KExprNode.Lit(KLiteral.Str(joined)))),
-                          0 => try_str_dec_eq(sa, sb, head, spine, types, top, addrs),
-                        },
-                      _ => (0, store(KExprNode.BVar(0))),
-                    },
-                  _ => (0, store(KExprNode.BVar(0))),
-                },
-              _ => (0, store(KExprNode.BVar(0))),
-            },
-          _ => (0, store(KExprNode.BVar(0))),
-        },
-      _ => (0, store(KExprNode.BVar(0))),
-    }
-  }
-
-  -- Mirror: crates/kernel/src/whnf.rs try_reduce_string_dec_eq.
-  -- `String.decEq` on two EQUAL literals → `Decidable.isTrue prop
-  -- (Eq.refl.{1} String lit)`. Unequal literals fall back to the
-  -- structural path (core Lean has no String analog of
-  -- `Nat.ne_of_beq_eq_false` to witness `isFalse` with). The prop slot
-  -- is recovered from the inferred `Decidable prop` type of the original
-  -- call, exactly as `decidable_finish` does; the witness is
-  -- proof-irrelevant, so any well-typed inhabitant is
-  -- defeq-indistinguishable from the structural reduction's.
-  fn try_str_dec_eq(sa: ByteStream, sb: ByteStream, head: KExpr,
-                    spine: List‹KExpr›, types: List‹KExpr›,
-                    top: List‹&KConstantInfo›,
-                    addrs: List‹Addr›) -> (G, KExpr) {
-    match bytestream_eq(sa, sb) {
-      0 => (0, store(KExprNode.BVar(0))),
-      1 =>
-        match find_addr_idx_safe(eq_refl_addr(), addrs, 0) {
-          (0, _) => (0, store(KExprNode.BVar(0))),
-          (1, eq_refl_idx) =>
-            match find_addr_idx_safe(str_addr(), addrs, 0) {
-              (0, _) => (0, store(KExprNode.BVar(0))),
-              (1, string_idx) =>
-                match find_addr_idx_safe(decidable_is_true_addr(), addrs, 0) {
-                  (0, _) => (0, store(KExprNode.BVar(0))),
-                  (1, is_true_idx) =>
-                    let call_expr = apply_spine(head, spine);
-                    let call_ty = k_infer(call_expr, types, top, addrs);
-                    let call_ty_w = whnf(call_ty, types, top, addrs);
-                    match collect_spine(call_ty_w) {
-                      (_, dec_args) =>
-                        match u32_less_than(list_length(dec_args), 1) {
-                          1 => (0, store(KExprNode.BVar(0))),
-                          0 =>
-                            let prop = list_lookup(dec_args, 0);
-                            -- Eq.refl.{1} String <lit> — String : Type =
-                            -- Sort 1, so u = 1.
-                            let one_lvl = store(KLevelNode.Succ(store(KLevelNode.Zero)));
-                            let lvls = store(ListNode.Cons(one_lvl, store(ListNode.Nil)));
-                            let eq_refl_const = store(KExprNode.Const(eq_refl_idx, lvls));
-                            let string_const = store(KExprNode.Const(string_idx, store(ListNode.Nil)));
-                            let lit = store(KExprNode.Lit(KLiteral.Str(sa)));
-                            let r1 = store(KExprNode.App(eq_refl_const, string_const));
-                            let refl = store(KExprNode.App(r1, lit));
-                            let is_true_const = store(KExprNode.Const(is_true_idx, store(ListNode.Nil)));
-                            let d1 = store(KExprNode.App(is_true_const, prop));
-                            (1, store(KExprNode.App(d1, refl))),
-                        },
-                    },
-                },
-            },
-        },
-    }
-  }
-
-  -- Mirror: crates/kernel/src/whnf.rs `String.ofList`/`String.mk` arm of
-  -- try_reduce_string + walk_literal_char_list: collapse a literal char
-  -- list to the `Str` literal — the exact inverse of `str_lit_to_ctor`.
-  -- Guards mirror Rust: list nodes and elements must whnf to literal
-  -- constructor form and every codepoint must be a valid Unicode scalar
-  -- (`Char.ofNat` maps invalid ones to '\0', so invalid literals must
-  -- keep reducing structurally). One arg exactly (Rust bails on
-  -- `args.len() != 1`). ofList and mk share one canonical address, so a
-  -- single dispatch address covers both spellings.
-  fn try_str_of_list(spine: List‹KExpr›, types: List‹KExpr›,
-                     top: List‹&KConstantInfo›, addrs: List‹Addr›) -> (G, KExpr) {
-    match list_length(spine) {
-      1 =>
-        match walk_char_list_bytes(list_lookup(spine, 0), types, top, addrs) {
-          (1, bs) => (1, store(KExprNode.Lit(KLiteral.Str(bs)))),
-          (0, _) => (0, store(KExprNode.BVar(0))),
-        },
-      _ => (0, store(KExprNode.BVar(0))),
-    }
-  }
-
-  -- Walk a `List Char` spine whose nodes whnf to literal ctor form,
-  -- UTF-8-encoding each element's codepoint into the result stream.
-  -- (0, _) on any non-literal node, wrong arity, or invalid codepoint —
-  -- the caller falls back to the structural path.
-  fn walk_char_list_bytes(list: KExpr, types: List‹KExpr›,
-                          top: List‹&KConstantInfo›, addrs: List‹Addr›) -> (G, ByteStream) {
-    let w = whnf(list, types, top, addrs);
-    match collect_spine(w) {
-      (head, args) =>
-        match load(head) {
-          KExprNode.Const(idx, _) =>
-            let a = list_lookup(addrs, idx);
-            match address_eq(a, list_nil_addr()) {
-              1 =>
-                match list_length(args) {
-                  1 => (1, store(ListNode.Nil)),
-                  _ => (0, store(ListNode.Nil)),
-                },
-              0 =>
-                match address_eq(a, list_cons_addr()) {
-                  0 => (0, store(ListNode.Nil)),
-                  1 =>
-                    match list_length(args) {
-                      3 =>
-                        match char_lit_codepoint(list_lookup(args, 1), types, top, addrs) {
-                          (0, _) => (0, store(ListNode.Nil)),
-                          (1, cp) =>
-                            match walk_char_list_bytes(list_lookup(args, 2), types, top, addrs) {
-                              (0, t) => (0, t),
-                              (1, t) => (1, utf8_encode_prepend(cp, t)),
-                            },
-                        },
-                      _ => (0, store(ListNode.Nil)),
-                    },
-                },
-            },
-          _ => (0, store(ListNode.Nil)),
-        },
-    }
-  }
-
-  -- Recognize the native char-value form `App(Const(Char.ofNat), Nat-lit)`
-  -- (whnf'ing the element when the syntactic match misses — mirror Rust
-  -- char_lit_value + the whnf_prim_arg retry) and return the codepoint,
-  -- guarded to valid Unicode scalar values.
-  fn char_lit_codepoint(e: KExpr, types: List‹KExpr›,
-                        top: List‹&KConstantInfo›, addrs: List‹Addr›) -> (G, G) {
-    match char_lit_codepoint_syn(e, addrs) {
-      (1, cp) => (1, cp),
-      (0, _) =>
-        let w = whnf(e, types, top, addrs);
-        char_lit_codepoint_syn(w, addrs),
-    }
-  }
-
-  fn char_lit_codepoint_syn(e: KExpr, addrs: List‹Addr›) -> (G, G) {
-    match load(e) {
-      KExprNode.App(f, arg) =>
-        match load(f) {
-          KExprNode.Const(idx, _) =>
-            match address_eq(list_lookup(addrs, idx), char_of_nat_addr()) {
-              0 => (0, 0),
-              1 =>
-                match load(arg) {
-                  KExprNode.Lit(lit) =>
-                    match lit {
-                      KLiteral.Nat(limbs) => klimbs_scalar_value(limbs),
-                      _ => (0, 0),
-                    },
-                  _ => (0, 0),
-                },
-            },
-          _ => (0, 0),
-        },
-      _ => (0, 0),
-    }
-  }
-
-  -- Single-limb KLimbs → codepoint, guarded to valid Unicode scalars
-  -- (mirror `char::from_u32`: rejects surrogates and > 0x10FFFF).
-  -- Multi-limb literals bail to the structural path.
-  fn klimbs_scalar_value(limbs: KLimbs) -> (G, G) {
-    match load(limbs) {
-      ListNode.Cons(limb, rest) =>
-        match load(rest) {
-          ListNode.Nil =>
-            let [b0, b1, b2, b3, b4, b5, b6, b7] = limb;
-            let hi = to_field(b3) + to_field(b4) + to_field(b5) + to_field(b6) + to_field(b7);
-            match eq_zero(hi) {
-              0 => (0, 0),
-              1 =>
-                let cp = to_field(b0) + to_field(b1) * 256 + to_field(b2) * 65536;
-                match u32_less_than(cp, 55296) {
-                  1 => (1, cp),
-                  0 =>
-                    match u32_less_than(57343, cp) {
-                      0 => (0, 0),
-                      1 =>
-                        match u32_less_than(cp, 1114112) {
-                          1 => (1, cp),
-                          0 => (0, 0),
-                        },
-                    },
-                },
-            },
-          _ => (0, 0),
-        },
-      _ => (0, 0),
-    }
-  }
-
-  -- Off-circuit 6-bit decomposition (repeated subtraction), only ever
-  -- invoked as `#utf8_groups(...)`; results are prover-provided and MUST
-  -- be pinned by the caller (u8 + window range checks, reconstruction
-  -- assert).
-  fn divmod_64u(x: G, q: G) -> (G, G) {
-    match u32_less_than(x, 64) {
-      1 => (x, q),
-      0 => divmod_64u(x - 64, q + 1),
-    }
-  }
-
-  fn utf8_groups(cp: G) -> (G, G, G, G) {
-    match divmod_64u(cp, 0) {
-      (g0, q1) =>
-        match divmod_64u(q1, 0) {
-          (g1, q2) =>
-            match divmod_64u(q2, 0) {
-              (g2, g3) => (g0, g1, g2, g3),
-            },
-        },
-    }
-  }
-
-  -- Constrained UTF-8 encode of a valid scalar `cp`, prepended to `tail`.
-  -- The 6-bit groups are a prover-provided witness pinned by u8 range
-  -- gadgets (u8_xor(_, 0)), window checks (< 64), and the base-64
-  -- reconstruction assert — the decomposition is unique, so the emitted
-  -- bytes are forced. The length class is selected by constrained
-  -- compares on `cp` (already guarded valid by the caller, so classes
-  -- are exhaustive and overlong encodings are unrepresentable).
-  fn utf8_encode_prepend(cp: G, tail: ByteStream) -> ByteStream {
-    match #utf8_groups(cp) {
-      (g0, g1, g2, g3) =>
-        let g0u = u8_xor(u8_from_field_unsafe(g0), 0u8);
-        let g1u = u8_xor(u8_from_field_unsafe(g1), 0u8);
-        let g2u = u8_xor(u8_from_field_unsafe(g2), 0u8);
-        let g3u = u8_xor(u8_from_field_unsafe(g3), 0u8);
-        let f0 = to_field(g0u);
-        let f1 = to_field(g1u);
-        let f2 = to_field(g2u);
-        let f3 = to_field(g3u);
-        assert_eq!(u32_less_than(f0, 64), 1);
-        assert_eq!(u32_less_than(f1, 64), 1);
-        assert_eq!(u32_less_than(f2, 64), 1);
-        assert_eq!(u32_less_than(f3, 64), 1);
-        assert_eq!(cp, f0 + f1 * 64 + f2 * 4096 + f3 * 262144);
-        match u32_less_than(cp, 128) {
-          1 => store(ListNode.Cons(u8_from_field_unsafe(cp), tail)),
-          0 =>
-            match u32_less_than(cp, 2048) {
-              1 =>
-                let t1 = u8_from_field_unsafe(f0 + 128);
-                let l1 = u8_from_field_unsafe(f1 + 192);
-                store(ListNode.Cons(l1, store(ListNode.Cons(t1, tail)))),
-              0 =>
-                match u32_less_than(cp, 65536) {
-                  1 =>
-                    let t2 = u8_from_field_unsafe(f0 + 128);
-                    let t1 = u8_from_field_unsafe(f1 + 128);
-                    let l2 = u8_from_field_unsafe(f2 + 224);
-                    store(ListNode.Cons(l2, store(ListNode.Cons(t1, store(ListNode.Cons(t2, tail)))))),
-                  0 =>
-                    let t3 = u8_from_field_unsafe(f0 + 128);
-                    let t2 = u8_from_field_unsafe(f1 + 128);
-                    let t1 = u8_from_field_unsafe(f2 + 128);
-                    let l3 = u8_from_field_unsafe(f3 + 240);
-                    store(ListNode.Cons(l3, store(ListNode.Cons(t1, store(ListNode.Cons(t2, store(ListNode.Cons(t3, tail)))))))),
-                },
-            },
-        },
-    }
-  }
-
-  -- Empty Lit(Str) → Const(byte_array_empty). Non-empty: defer.
-  fn try_str_to_byte_array(bs: ByteStream, addrs: List‹Addr›) -> (G, KExpr) {
-    match load(bs) {
-      ListNode.Nil =>
-        match find_addr_idx_safe(byte_array_empty_addr(), addrs, 0) {
-          (1, idx) => (1, store(KExprNode.Const(idx, store(ListNode.Nil)))),
-          (0, _) => (0, store(KExprNode.BVar(0))),
-        },
-      _ => (0, store(KExprNode.BVar(0))),
-    }
-  }
-
-  -- String.back/legacy_back over Lit(Str(s)) →
-  -- App(Const(char_of_nat), Lit(Nat(last_codepoint))). Empty → 65 ('A').
-  fn try_str_back(bs: ByteStream, addrs: List‹Addr›) -> (G, KExpr) {
-    match find_addr_idx_safe(char_of_nat_addr(), addrs, 0) {
-      (0, _) => (0, store(KExprNode.BVar(0))),
-      (1, idx) =>
-        let cp = utf8_last_codepoint(bs);
-        let cp_limbs = klimbs_from_g(cp);
-        let cp_lit = store(KExprNode.Lit(KLiteral.Nat(cp_limbs)));
-        let con = store(KExprNode.Const(idx, store(ListNode.Nil)));
-        (1, store(KExprNode.App(con, cp_lit))),
-    }
-  }
-
-  -- Unconstrained witness generator: split `x` (< 2^32) into 4
-  -- little-endian bytes. Always invoked as `#split_u32(...)`; the result
-  -- is prover-provided and MUST be pinned by the caller with u8 range
-  -- checks + a reconstruction assert. Division is off-circuit (untraced).
-  fn split_u32(x: G) -> (G, G, G, G) {
-    match divmod_256(x, 0) {
-      (b0, q1) =>
-        match divmod_256(q1, 0) {
-          (b1, q2) =>
-            match divmod_256(q2, 0) {
-              (b2, q3) =>
-                match divmod_256(q3, 0) {
-                  (b3, _) => (b0, b1, b2, b3),
-                },
-            },
-        },
-    }
-  }
-
-  -- Convert G value (< 2^32) into single-limb KLimbs. The 4-byte
-  -- decomposition is a prover-provided (unconstrained) witness, pinned by
-  -- four u8 range checks + the reconstruction assert. `x >= 2^32` is
-  -- rejected (assert fails) rather than silently truncated.
-  fn klimbs_from_g(x: G) -> KLimbs {
-    match #split_u32(x) {
-      (rb0, rb1, rb2, rb3) =>
-        let b0 = u8_xor(u8_from_field_unsafe(rb0), 0u8);
-        let b1 = u8_xor(u8_from_field_unsafe(rb1), 0u8);
-        let b2 = u8_xor(u8_from_field_unsafe(rb2), 0u8);
-        let b3 = u8_xor(u8_from_field_unsafe(rb3), 0u8);
-        assert_eq!(x, to_field(b0) + (256 * to_field(b1)) + (65536 * to_field(b2)) + (16777216 * to_field(b3)));
-        store(ListNode.Cons([b0, b1, b2, b3, 0u8, 0u8, 0u8, 0u8],
-                            store(ListNode.Nil))),
-    }
-  }
-
-  -- Walk byte stream forward decoding UTF-8 codepoints; return last.
-  -- Empty → 65 ('A') per Rust default.
-  fn utf8_last_codepoint(bs: ByteStream) -> G {
-    utf8_last_go(bs, 65)
-  }
-
-  fn utf8_last_go(bs: ByteStream, prev: G) -> G {
-    match load(bs) {
-      ListNode.Nil => prev,
-      ListNode.Cons(b0, rest) =>
-        match utf8_decode_one(b0, rest) {
-          (cp, remaining) => utf8_last_go(remaining, cp),
-        },
-    }
-  }
-
-  -- Decode one UTF-8 codepoint. Honors length prefix bits:
-  -- 0xxxxxxx → 1 byte; 110xxxxx 10xxxxxx → 2; 1110xxxx 10*2 → 3;
-  -- 11110xxx 10*3 → 4 bytes.
-  fn utf8_decode_one(b0: U8, rest: ByteStream) -> (G, ByteStream) {
-    match u8_less_than(b0, 128u8) {
-      1 => (to_field(b0), rest),
-      0 =>
-        match u8_less_than(b0, 224u8) {
-          1 =>
-            match load(rest) {
-              ListNode.Cons(b1, r1) =>
-                let cp = (to_field(b0) - 192) * 64 + (to_field(b1) - 128);
-                (cp, r1),
-            },
-          0 =>
-            match u8_less_than(b0, 240u8) {
-              1 =>
-                match load(rest) {
-                  ListNode.Cons(b1, r1) =>
-                    match load(r1) {
-                      ListNode.Cons(b2, r2) =>
-                        let cp = (to_field(b0) - 224) * 4096 + (to_field(b1) - 128) * 64 + (to_field(b2) - 128);
-                        (cp, r2),
-                    },
-                },
-              0 =>
-                match load(rest) {
-                  ListNode.Cons(b1, r1) =>
-                    match load(r1) {
-                      ListNode.Cons(b2, r2) =>
-                        match load(r2) {
-                          ListNode.Cons(b3, r3) =>
-                            let cp = (to_field(b0) - 240) * 262144 + (to_field(b1) - 128) * 4096
-                                    + (to_field(b2) - 128) * 64 + (to_field(b3) - 128);
-                            (cp, r3),
-                        },
-                    },
-                },
-            },
-        },
-    }
-  }
-
-  -- Mirror: src/ix/kernel/def_eq.rs:1025-1060 fn str_lit_to_constructor.
-  -- Expand a Lit(Str(bs)) to ctor form
-  -- `String.ofList (List.cons.{0} Char (Char.ofNat c) (... List.nil.{0} Char))`.
-  -- Returns (1, expanded) when all required ctor addrs in `addrs`, else (0, _).
-  fn str_lit_to_ctor(bs: ByteStream, addrs: List‹Addr›) -> (G, KExpr) {
-    match find_addr_idx_safe(list_nil_addr(), addrs, 0) {
-      (0, _) => (0, store(KExprNode.BVar(0))),
-      (1, nil_idx) =>
-        match find_addr_idx_safe(list_cons_addr(), addrs, 0) {
-          (0, _) => (0, store(KExprNode.BVar(0))),
-          (1, cons_idx) =>
-            match find_addr_idx_safe(char_type_addr(), addrs, 0) {
-              (0, _) => (0, store(KExprNode.BVar(0))),
-              (1, char_idx) =>
-                match find_addr_idx_safe(char_of_nat_addr(), addrs, 0) {
-                  (0, _) => (0, store(KExprNode.BVar(0))),
-                  (1, con_idx) =>
-                    match find_addr_idx_safe(string_of_list_addr(), addrs, 0) {
-                      (0, _) => (0, store(KExprNode.BVar(0))),
-                      (1, str_idx) =>
-                        let zero_lvl = store(KLevelNode.Zero);
-                        let ulvls = store(ListNode.Cons(zero_lvl, store(ListNode.Nil)));
-                        let nil_const = store(KExprNode.Const(nil_idx, ulvls));
-                        let cons_const = store(KExprNode.Const(cons_idx, ulvls));
-                        let char_const = store(KExprNode.Const(char_idx, store(ListNode.Nil)));
-                        let con_const = store(KExprNode.Const(con_idx, store(ListNode.Nil)));
-                        let str_const = store(KExprNode.Const(str_idx, store(ListNode.Nil)));
-                        let nil_app = store(KExprNode.App(nil_const, char_const));
-                        let cons_partial = store(KExprNode.App(cons_const, char_const));
-                        let list_expr = build_char_list(bs, nil_app, cons_partial, con_const);
-                        (1, store(KExprNode.App(str_const, list_expr))),
-                    },
-                },
-            },
-        },
-    }
-  }
-
-  fn build_char_list(bs: ByteStream, nil_app: KExpr,
-                     cons_partial: KExpr, con_const: KExpr) -> KExpr {
-    match load(bs) {
-      ListNode.Nil => nil_app,
-      ListNode.Cons(b0, rest) =>
-        match utf8_decode_one(b0, rest) {
-          (cp, remaining) =>
-            let cp_limbs = klimbs_from_g(cp);
-            let cp_lit = store(KExprNode.Lit(KLiteral.Nat(cp_limbs)));
-            let char_val = store(KExprNode.App(con_const, cp_lit));
-            let with_head = store(KExprNode.App(cons_partial, char_val));
-            let tail = build_char_list(remaining, nil_app, cons_partial, con_const);
-            store(KExprNode.App(with_head, tail)),
-        },
-    }
-  }
-
-  -- If `e` is `Lit(Str(bs))` and addrs has required ctors, expand to ctor form.
-  -- Else return `e` unchanged. Used pre-iota.
-  fn str_lit_to_ctor_or_self(e: KExpr, addrs: List‹Addr›) -> KExpr {
-    match load(e) {
-      KExprNode.Lit(lit) =>
-        match lit {
-          KLiteral.Str(bs) =>
-            match str_lit_to_ctor(bs, addrs) {
-              (1, expanded) => expanded,
-              (0, _) => e,
-            },
-          _ => e,
-        },
-      _ => e,
-    }
-  }
-
-  -- Mirror: crates/kernel/src/def_eq.rs str_lit_to_ctor_app — take ONE
-  -- delta step past `String.ofList` when it is a Defn (real compiled
-  -- envs, where the ctor head is `String.ofByteArray`): with the native
-  -- ofList collapse in try_str_dispatch, a whnf of the raw ofList
-  -- application would fold straight back into the `Str` literal and the
-  -- consumer would never reach the constructor form. In envs where the
-  -- ofList address IS the constructor (List-Char-model test envs), the
-  -- step is a no-op and the expansion is already ctor-headed. `whnf_nd`
-  -- settles the unfolded body (beta/zeta) without re-running the string
-  -- native on an ofList head.
-  fn str_lit_delta_step(expanded: KExpr, types: List‹KExpr›,
-                        top: List‹&KConstantInfo›, addrs: List‹Addr›) -> KExpr {
-    match load(expanded) {
-      KExprNode.App(f, list_arg) =>
-        match load(f) {
-          KExprNode.Const(idx, _) =>
-            let ci = load(list_lookup(top, idx));
-            match ci {
-              KConstantInfo.Defn(_, _, value, _, _) =>
-                let body = expr_inst_levels(value, store(ListNode.Nil));
-                match load(body) {
-                  KExprNode.Lam(_, lam_body) =>
-                    whnf_nd(expr_inst1(lam_body, list_arg, 0), types, top, addrs),
-                  _ => whnf_nd(store(KExprNode.App(body, list_arg)), types, top, addrs),
-                },
-              _ => expanded,
-            },
-          _ => expanded,
-        },
-      _ => expanded,
-    }
-  }
-
-  -- `str_lit_to_ctor_or_self` with the delta step — the form consumers
-  -- that re-reduce or structurally compare the expansion must use.
-  fn str_lit_to_ctor_app_or_self(e: KExpr, types: List‹KExpr›,
-                                 top: List‹&KConstantInfo›, addrs: List‹Addr›) -> KExpr {
-    match load(e) {
-      KExprNode.Lit(lit) =>
-        match lit {
-          KLiteral.Str(bs) =>
-            match str_lit_to_ctor(bs, addrs) {
-              (1, expanded) => str_lit_delta_step(expanded, types, top, addrs),
-              (0, _) => e,
-            },
-          _ => e,
-        },
-      _ => e,
-    }
-  }
-
-  -- Mirror: src/ix/kernel/whnf.rs:1531-1585 try_reduce_projection_definition
-  -- + projection_definition_info.
-  --
-  -- Recognizes Defn-kind constants whose body is `λ x_1 ... x_n → Prj S i (BVar k)`
-  -- and shortcuts the unfolding to a direct `Prj S i args[arity-1-k]`. Pure
-  -- performance: standard delta+beta still produces same result.
-  fn try_reduce_projection_definition(head_idx: G, spine: List‹KExpr›,
-                                       top: List‹&KConstantInfo›) -> (G, KExpr) {
-    match load(list_lookup(top, head_idx)) {
-      KConstantInfo.Defn(_, _, value, _, _) =>
-        match projection_definition_info(value, 0) {
-          (1, arity, struct_idx, field, struct_arg_idx) =>
-            match u32_less_than(list_length(spine), arity) {
-              1 => (0, store(KExprNode.BVar(0))),
-              0 =>
-                let target_arg = list_lookup(spine, struct_arg_idx);
-                let proj_expr = store(KExprNode.Proj(struct_idx, field, target_arg));
-                let post = list_drop(spine, arity);
-                (1, apply_spine(proj_expr, post)),
-            },
-          _ => (0, store(KExprNode.BVar(0))),
-        },
-      _ => (0, store(KExprNode.BVar(0))),
-    }
-  }
-
-  -- Mirror: src/ix/kernel/whnf.rs:1441-1500 try_reduce_fin_val_decidable_rec
-  -- + project_decidable_fin_val_minor.
-  --
-  -- Pushes `Fin.val` projection inside `Decidable.rec` minors when the
-  -- structure type is Fin and field 0. Allows iota to fire once major is
-  -- a concrete `Decidable.isTrue/isFalse`.
-  fn try_reduce_fin_val_decidable_rec(tidx: G, field: G, head: KExpr,
-                                       args: List‹KExpr›,
-                                       addrs: List‹Addr›) -> (G, KExpr) {
-    let tidx_addr = list_lookup(addrs, tidx);
-    match address_eq(tidx_addr, fin_addr()) {
-      0 => (0, store(KExprNode.BVar(0))),
-      1 =>
-        match field {
-          0 =>
-            match load(head) {
-              KExprNode.Const(rec_idx, rec_us) =>
-                let rec_addr_ = list_lookup(addrs, rec_idx);
-                match address_eq(rec_addr_, decidable_rec_addr()) {
-                  0 => (0, store(KExprNode.BVar(0))),
-                  1 =>
-                    match u32_less_than(list_length(args), 5) {
-                      1 => (0, store(KExprNode.BVar(0))),
-                      0 =>
-                        let a0 = list_lookup(args, 0);
-                        let a1 = list_lookup(args, 1);
-                        let a2 = list_lookup(args, 2);
-                        let a3 = list_lookup(args, 3);
-                        let a4 = list_lookup(args, 4);
-                        match load(a1) {
-                          KExprNode.Lam(motive_dom, _) =>
-                            -- Inline project_decidable_fin_val_minor twice.
-                            match load(a2) {
-                              KExprNode.Lam(fdom, fbody) =>
-                                let fproj = store(KExprNode.Proj(tidx, field, fbody));
-                                let false_minor = store(KExprNode.Lam(fdom, fproj));
-                                match load(a3) {
-                                  KExprNode.Lam(tdom, tbody) =>
-                                    let tproj = store(KExprNode.Proj(tidx, field, tbody));
-                                    let true_minor = store(KExprNode.Lam(tdom, tproj));
-                                    match find_addr_idx_safe(nat_addr(), addrs, 0) {
-                                      (1, nat_idx) =>
-                                        let nat_ty = store(KExprNode.Const(nat_idx, store(ListNode.Nil)));
-                                        let new_motive = store(KExprNode.Lam(motive_dom, nat_ty));
-                                        let head_const = store(KExprNode.Const(rec_idx, rec_us));
-                                        let r1 = store(KExprNode.App(head_const, a0));
-                                        let r2 = store(KExprNode.App(r1, new_motive));
-                                        let r3 = store(KExprNode.App(r2, false_minor));
-                                        let r4 = store(KExprNode.App(r3, true_minor));
-                                        let r5 = store(KExprNode.App(r4, a4));
-                                        let post = list_drop(args, 5);
-                                        (1, apply_spine(r5, post)),
-                                      (0, _) => (0, store(KExprNode.BVar(0))),
-                                    },
-                                  _ => (0, store(KExprNode.BVar(0))),
-                                },
-                              _ => (0, store(KExprNode.BVar(0))),
-                            },
-                          _ => (0, store(KExprNode.BVar(0))),
-                        },
-                    },
-                },
-              _ => (0, store(KExprNode.BVar(0))),
-            },
-          _ => (0, store(KExprNode.BVar(0))),
-        },
-    }
-  }
-
-  -- Returns (found, arity, struct_idx, field, struct_arg_idx). Walks Lam
-  -- bindings counting arity; expects body to be `Prj S i (BVar k)` with
-  -- `k < arity`. struct_arg_idx = (arity - 1) - k.
-  fn projection_definition_info(val: KExpr, arity: G) -> (G, G, G, G, G) {
-    match load(val) {
-      KExprNode.Lam(_, body) =>
-        projection_definition_info(body, arity + 1),
-      KExprNode.Proj(struct_idx, field, projected) =>
-        match load(projected) {
-          KExprNode.BVar(i) =>
-            match u32_less_than(i, arity) {
-              1 => (1, arity, struct_idx, field, (arity - 1) - i),
-              _ => (0, 0, 0, 0, 0),
-            },
-          _ => (0, 0, 0, 0, 0),
-        },
-      _ => (0, 0, 0, 0, 0),
-    }
-  }
-⟧
-
-end IxVM
-
-end
diff --git a/Ix/IxVM/Kernel/Subst.lean b/Ix/IxVM/Kernel/Subst.lean
index 33c54f65b..c6b256893 100644
--- a/Ix/IxVM/Kernel/Subst.lean
+++ b/Ix/IxVM/Kernel/Subst.lean
@@ -8,7 +8,7 @@ namespace IxVM
 
 /-! ## Substitution primitives over `KExpr`
 
-Mirror: src/ix/kernel/subst.rs (full file).
+Mirror: crates/kernel/src/subst.rs (full file).
 
 Two core operations:
 
@@ -42,7 +42,7 @@ def subst := ⟦
   -- O(1). First traversal cost matches a single subst walk; the payoff is
   -- short-circuiting subst that would otherwise re-walk closed subtrees.
   --
-  -- Mirror: src/ix/kernel/expr.rs::lbr field on KExprNode (precomputed at
+  -- Mirror: crates/kernel/src/expr.rs::lbr field on KExprNode (precomputed at
   -- intern time in Rust; computed on demand here, memoized via `store`).
   -- ============================================================================
   fn expr_lbr(e: KExpr) -> G {
@@ -230,7 +230,7 @@ def subst := ⟦
   -- Shift `BVar(i)` → `BVar(i + shift)` when `i ≥ cutoff`. Recursion bumps
   -- `cutoff` by 1 when crossing a binder (Lam/Forall/Let).
   --
-  -- Mirrors `src/ix/kernel/subst.rs::lift_no_intern` (line 364-415).
+  -- Mirrors `crates/kernel/src/subst.rs::lift_no_intern` (line 364-415).
   -- Fast path: when `expr_lbr(e) <= cutoff`, no loose BVar at or above the
   -- cutoff exists, so `e` is unchanged.
   -- ============================================================================
@@ -358,7 +358,7 @@ def subst := ⟦
   -- Substitute `BVar(depth)` with `expr_lift(arg, depth, 0)` and decrement
   -- `BVar(i)` for `i > depth`. Crossing a binder bumps `depth`.
   --
-  -- Mirrors the single-arg form of `src/ix/kernel/subst.rs::instantiate_rev`
+  -- Mirrors the single-arg form of `crates/kernel/src/subst.rs::instantiate_rev`
   -- with a list of one element. For the lambda-eta case in def_eq we want
   -- `body[BVar(0) := arg]` which is `expr_inst1(body, arg, 0)`.
   -- ============================================================================
@@ -422,7 +422,7 @@ def subst := ⟦
 
   -- ============================================================================
   -- expr_inst_many — simultaneous substitution of `substs` for the `n` binders
-  -- at `depth` in ONE walk (mirror `src/ix/kernel/subst.rs::simul_subst`). Used
+  -- at `depth` in ONE walk (mirror `crates/kernel/src/subst.rs::simul_subst`). Used
   -- for multi-arg beta: `(λλλ. body) x y z` substitutes all three at once
   -- instead of three separate `expr_inst1` re-walks of the body.
   --
diff --git a/Ix/IxVM/Kernel/Whnf.lean b/Ix/IxVM/Kernel/Whnf.lean
index 954501632..0e74cf488 100644
--- a/Ix/IxVM/Kernel/Whnf.lean
+++ b/Ix/IxVM/Kernel/Whnf.lean
@@ -3,46 +3,31 @@ 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.Primitive
+public import Ix.IxVM.Kernel.NatPrim
+public import Ix.IxVM.Ingress
 
 public section
 
 namespace IxVM
 
-/-! ## Weak Head Normal Form over `KExpr`
-
-Mirrors `src/ix/kernel/whnf.rs`.
-
-Reduces an expression to head-canonical form. The head after WHNF is one of:
-
-* `Sort(level)` — universe.
-* `Lam(ty, body)` — function value.
-* `Forall(ty, body)` — function type.
-* `Const(idx, lvls)` applied to args where the constant is non-reducible
-  (Axiom, Indc, Ctor, Recr stuck on non-Ctor major).
-* `BVar(i)` applied to args (open term).
-* `Let(...)` — never (always reduces via zeta).
-* `Lit(...)` — already a value.
-* `Proj(...)` stuck on non-Ctor.
-
-This file implements the essential phases:
-
-1. **delta**: `Const(idx)` where the constant is `Defn` or `Thm` →
-   unfold value, instantiate level params, reapply spine, recurse.
-2. **beta**: `App(Lam(_, body), arg)` → `body[BVar(0) := arg]`, recurse.
-3. **zeta**: `Let(_, val, body)` → `body[BVar(0) := val]`, recurse.
-4. **proj**: `Proj(tidx, fidx, e)` where `e` reduces to a `Ctor` →
-   pull field via the ctor's spine, recurse.
-5. **iota**: `Const(Recr) spine` where `spine[major_idx]` reduces to a
-   `Ctor` → look up rule by ctor's `cidx`, instantiate RHS with rec
-   levels, apply the params/motives/minors prefix of the spine, then
-   ctor's tail fields, then post-major spine; recurse.
-6. **nat-prim** (`prims` argument): when `Const(idx)` head matches a
-   primitive Nat op slot in `prims` and the spine carries `Lit(Nat(_))`
-   args, fold to the literal result.
-
-`addrs: List‹Addr›` carries primitive positional indices threaded from
-ingress (slot mapping in `Primitive.lean`).
+/-! ## Weak Head Normal Form
+
+Two reducers live here, differing only in whether delta fires:
+
+* `whnf` — the full reducer. Beta, zeta, iota (recursors, including the
+  K rule and structure eta), quotient lifting/induction, projections,
+  the Nat/BitVec/String primitive fast-paths, and delta on `Defn`.
+  `Thm` heads stay stuck: a theorem only unfolds through def-eq's
+  lazy-delta step, never by plain reduction.
+* `whnf_nd` — the no-delta reducer (`_nd` suffix throughout). Everything
+  above except delta, so `Defn` and `Thm` heads both stay stuck. Def-eq
+  reduces with this first, since it is far cheaper and often enough to
+  decide a pair, and only then pays for unfolding.
+
+`get_ci(addr)` fault-loads and memoizes, so reduction needs no ambient
+constant table — an addr is self-sufficient. The `types` argument is the
+local binder context, threaded for the inference calls that gate the K
+rule and structure eta.
 -/
 
 def whnf := ⟦
@@ -54,26 +39,9 @@ def whnf := ⟦
     }
   }
 
-  -- ============================================================================
-  -- Beta
-  --
-  -- One argument per step, NOT a simultaneous multi-arg substitution: a
-  -- measured choice. A simultaneous `instantiate_rev`-style peel was
-  -- tried (2026-06-10) and REGRESSED FFT ~3%: recursor betas share a
-  -- constant argument prefix across iterations (motive/base/step), so
-  -- the sequential chain's per-arg memo keys hit across every iteration,
-  -- while a combined args-list key is unique per iteration and re-walks
-  -- the whole body each time. Curried beats tupled under Aiur's
-  -- content-memoization.
-  -- ============================================================================
-
-  -- Peel a beta telescope: consume one spine arg per leading `Lam` of `lam`,
-  -- accumulating the consumed args innermost-first in `acc` (prepend), until
-  -- the head is no longer a `Lam` or the spine is empty. Returns the deepest
-  -- body, the consumed args (innermost-first, ready for `expr_inst_many`), and
-  -- the unconsumed spine tail.
+  -- Peel `Lam` telescope against spine, one arg per Lam.
   fn peel_beta(lam: KExpr, spine: List‹KExpr›, acc: List‹KExpr›)
-              -> (KExpr, List‹KExpr›, List‹KExpr›) {
+                  -> (KExpr, List‹KExpr›, List‹KExpr›) {
     match load(lam) {
       KExprNode.Lam(_, body) =>
         match load(spine) {
@@ -85,666 +53,779 @@ def whnf := ⟦
     }
   }
 
-  -- ============================================================================
-  -- WHNF main loop with `prims` for nat-primitive dispatch.
-  -- ============================================================================
-
-  -- Multi-arg beta (mirror src/ix/kernel/whnf.rs:541-567): peel the whole
+  -- Multi-arg beta (mirror crates/kernel/src/whnf.rs): peel the whole
   -- telescope and substitute all consumed args in ONE `expr_inst_many` walk,
   -- instead of one `expr_inst1` re-walk of the body per arg. Single-arg betas
   -- stay on the cheap `expr_inst1` path (no list overhead).
-  fn whnf_apply_beta(spine: List‹KExpr›, lam: KExpr, types: List‹KExpr›,
-                     top: List‹&KConstantInfo›, addrs: List‹Addr›) -> KExpr {
+  fn whnf_apply_beta(spine: List‹KExpr›, lam: KExpr, types: List‹KExpr›) -> KExpr {
     match peel_beta(lam, spine, store(ListNode.Nil)) {
       (deep, consumed, rest) =>
         match list_length(consumed) {
           0 => apply_spine(lam, spine),
           1 =>
             let body2 = expr_inst1(deep, list_lookup(consumed, 0), 0);
-            whnf_with_spine(body2, rest, types, top, addrs),
+            whnf_with_spine(body2, rest, types),
           _ =>
             let body2 = expr_inst_many(deep, consumed, 0);
-            whnf_with_spine(body2, rest, types, top, addrs),
+            whnf_with_spine(body2, rest, types),
         },
     }
   }
 
-  fn whnf_with_spine(head: KExpr, spine: List‹KExpr›, types: List‹KExpr›,
-                     top: List‹&KConstantInfo›, addrs: List‹Addr›) -> KExpr {
+  fn whnf_with_spine(head: KExpr, spine: List‹KExpr›, types: List‹KExpr›) -> KExpr {
     match load(head) {
       KExprNode.App(f, a) =>
-        -- Head is itself App-spine (post-beta result). Collect its spine
-        -- and prepend to the outer spine, then recurse. Without this,
-        -- post-delta beta-reduced bodies like `Nat.rec PUnit step n`
-        -- stay stuck and iota never fires.
         match collect_spine(head) {
           (inner_head, inner_spine) =>
-            whnf_with_spine(inner_head, list_concat(inner_spine, spine), types, top, addrs),
+            whnf_with_spine(inner_head, list_concat(inner_spine, spine), types),
         },
       KExprNode.Lam(ty, body) =>
-        whnf_apply_beta(spine, head, types, top, addrs),
-      KExprNode.Const(idx, lvls) =>
-        -- Const-head reduction (delta / iota / quot / primitive dispatch) is the
-        -- widest arm by far. Factored into `whnf_const_head` so `whnf_with_spine`
-        -- stays narrow for the ~76% of reduction steps that are App/Lam/Proj —
-        -- Aiur charges a function's full width on every row, so the wide dispatch
-        -- only taxes the Const-head rows in its own circuit.
-        whnf_const_head(idx, lvls, head, spine, types, top, addrs),
+        whnf_apply_beta(spine, head, types),
+      KExprNode.Const(addr, lvls) =>
+        whnf_const_head(addr, lvls, head, spine, types),
       KExprNode.Let(_, val, body) =>
         let next = expr_inst1(body, val, 0);
-        whnf_with_spine(next, spine, types, top, addrs),
-      KExprNode.Proj(tidx, fidx, inner) =>
-        -- Proj reduction (whnf the scrutinee, fin-val rewrite, ctor field pull)
-        -- is the next-widest arm. Factored out for the same reason as Const.
-        whnf_proj_head(tidx, fidx, inner, spine, types, top, addrs),
+        whnf_with_spine(next, spine, types),
+      KExprNode.Proj(struct_addr, fidx, inner) =>
+        whnf_proj_head(struct_addr, fidx, inner, spine, types),
       _ => apply_spine(head, spine),
     }
   }
 
-  -- Proj-head WHNF dispatch, split out of `whnf_with_spine` (see its Proj arm).
-  fn whnf_proj_head(tidx: G, fidx: G, inner: KExpr, spine: List‹KExpr›,
-                    types: List‹KExpr›, top: List‹&KConstantInfo›, addrs: List‹Addr›) -> KExpr {
-    let inner_whnf = whnf(inner, types, top, addrs);
-    -- Str-literal scrutinee → constructor form (mirror whnf.rs's proj
-    -- expansion site): with the native ofList collapse a constructor
-    -- build whnfs to the literal, so the field pull needs the
-    -- delta-stepped re-expansion. Stuck fallbacks keep `inner_whnf`
-    -- (the literal), not the expansion.
-    let inner_exp = str_lit_to_ctor_app_or_self(inner_whnf, types, top, addrs);
-    let inner_pair = collect_spine(inner_exp);
-    match inner_pair {
+  -- Proj-head WHNF: whnf inner, if it's a Ctor application, pull the
+  -- corresponding field.  Otherwise stays stuck as `Proj(struct, fidx, inner_whnf)`.
+  -- : try_reduce_fin_val_decidable_rec hook — Fin.val on
+  -- Decidable.rec pushes Proj inside minors, unblocks iota once
+  -- major is Decidable.isTrue/isFalse.
+  fn whnf_proj_head(struct_addr: Addr, fidx: G, inner: KExpr,
+                        spine: List‹KExpr›, types: List‹KExpr›) -> KExpr {
+    let inner_whnf = whnf(inner, types);
+    -- Str-literal re-expansion (mirror whnf_proj_head): a Proj over
+    -- a Lit(Str) scrutinee needs the ctor form to pull fields.
+    let inner_exp = str_lit_to_ctor_app_or_self(inner_whnf, types);
+    match collect_spine(inner_exp) {
       (inner_head, inner_args) =>
-        -- Mirror: whnf.rs:1441-1500 try_reduce_fin_val_decidable_rec.
-        -- Pushes Fin.val inside Decidable.rec minors; allows iota.
-        let fvd_pair = try_reduce_fin_val_decidable_rec(tidx, fidx, inner_head, inner_args, addrs);
-        match fvd_pair {
-          (1, rewritten) => whnf_with_spine(rewritten, spine, types, top, addrs),
-          (0, _) =>
+        match try_reduce_fin_val_decidable_rec(struct_addr, fidx,
+                inner_head, inner_args) {
+          (1, rewritten) => whnf_with_spine(rewritten, spine, types),
+          _ =>
             match load(inner_head) {
-              KExprNode.Const(cidx, _) =>
-                let cci = load(list_lookup(top, cidx));
-                match cci {
-                  KConstantInfo.Ctor(_, _, _, _, nparams, _, _) =>
-                    let field = list_lookup_or_nil(inner_args, nparams + fidx);
-                    whnf_with_spine(field, spine, types, top, addrs),
+              KExprNode.Const(_, _) =>
+                match load(whnf_get_ctor_or_none(inner_head)) {
+                  KConstantInfo.Ctor(_, _, _, _, _, nparams, _, _) =>
+                    let field = list_lookup(inner_args, nparams + fidx);
+                    whnf_with_spine(field, spine, types),
                   _ =>
-                    let stuck = store(KExprNode.Proj(tidx, fidx, inner_whnf));
+                    let stuck = store(KExprNode.Proj(struct_addr, fidx, inner_whnf));
                     apply_spine(stuck, spine),
                 },
               _ =>
-                let stuck = store(KExprNode.Proj(tidx, fidx, inner_whnf));
+                let stuck = store(KExprNode.Proj(struct_addr, fidx, inner_whnf));
                 apply_spine(stuck, spine),
             },
         },
     }
   }
 
-  -- Const-head WHNF dispatch, split out of `whnf_with_spine` (see its Const arm).
-  -- `head` is the original `Const(idx, lvls)` KExpr, passed for the stuck
-  -- `apply_spine(head, spine)` fallbacks.
-  fn whnf_const_head(idx: G, lvls: List‹KLevel›, head: KExpr, spine: List‹KExpr›,
-                     types: List‹KExpr›, top: List‹&KConstantInfo›, addrs: List‹Addr›) -> KExpr {
-    let head_addr = list_lookup(addrs, idx);
-    let ci = load(list_lookup(top, idx));
-    -- Recr / Quot heads can never match a primitive address (Nat ops,
-    -- Str ops, BitVec, native, decidable, proj-def all live as Ctor or
-    -- Defn). Skip the primitive dispatch chain for those.
-    match ci {
-      KConstantInfo.Rec(num_lvls, _, num_params, num_indices, num_motives, num_minors, rules, k_flag, _, _) =>
-        let iota = try_iota(lvls, spine, num_lvls, num_params, num_indices, num_motives, num_minors, rules, k_flag, types, top, addrs);
-        match iota {
-          (1, reduced2) => whnf(reduced2, types, top, addrs),
-          (0, _) => apply_spine(head, spine),
+  fn fin_addr() -> Addr {
+    store([0x74u8, 0x59u8, 0x36u8, 0xfcu8, 0xb9u8, 0xd8u8, 0x6cu8, 0x44u8,
+     0x57u8, 0xf0u8, 0xfdu8, 0x1eu8, 0x53u8, 0x7eu8, 0x67u8, 0x07u8,
+     0x7fu8, 0x46u8, 0xf7u8, 0x84u8, 0x11u8, 0x08u8, 0x41u8, 0x9du8,
+     0xacu8, 0x79u8, 0x84u8, 0x00u8, 0x8bu8, 0x56u8, 0x5bu8, 0x97u8])
+  }
+
+  fn decidable_rec_addr() -> Addr {
+    store([0xabu8, 0x37u8, 0x76u8, 0x98u8, 0x57u8, 0x43u8, 0xafu8, 0x13u8,
+     0xa9u8, 0xcbu8, 0x1au8, 0x7du8, 0x2fu8, 0x84u8, 0x96u8, 0x99u8,
+     0x78u8, 0x92u8, 0xe1u8, 0x79u8, 0x83u8, 0xd1u8, 0x4bu8, 0xe5u8,
+     0x27u8, 0x0au8, 0x71u8, 0x65u8, 0x70u8, 0xb3u8, 0x57u8, 0x19u8])
+  }
+
+  fn nat_ty_addr() -> Addr {
+    store([0x39u8, 0x8au8, 0x77u8, 0x06u8, 0xcfu8, 0x13u8, 0xf2u8, 0x23u8,
+     0x99u8, 0x2du8, 0x17u8, 0x3du8, 0xceu8, 0x07u8, 0x94u8, 0x68u8,
+     0x57u8, 0x24u8, 0x0fu8, 0x49u8, 0xafu8, 0xccu8, 0x74u8, 0x37u8,
+     0x23u8, 0xe8u8, 0x39u8, 0xf8u8, 0xf3u8, 0xf2u8, 0xb6u8, 0x31u8])
+  }
+
+  -- Mirror try_reduce_fin_val_decidable_rec (Primitive.lean:3141+).
+  -- Rewrites `Proj Fin 0 (Decidable.rec α motive f_min t_min major post)`
+  -- to  `Decidable.rec α (fun _ => Nat)
+  --          (fun x => Proj Fin 0 (f_min x))
+  --          (fun x => Proj Fin 0 (t_min x)) major post`
+  -- so iota fires once major = Decidable.isTrue/isFalse.
+  fn try_reduce_fin_val_decidable_rec(struct_addr: Addr, fidx: G,
+                                            inner_head: KExpr,
+                                            inner_args: List‹KExpr›)
+                                            -> (G, KExpr) {
+    match address_eq(struct_addr, fin_addr()) {
+      0 => (0, store(KExprNode.BVar(0))),
+      _ =>
+        match fidx {
+          0 =>
+            match load(inner_head) {
+              KExprNode.Const(rec_addr, rec_us) =>
+                match address_eq(rec_addr, decidable_rec_addr()) {
+                  0 => (0, store(KExprNode.BVar(0))),
+                  _ =>
+                    match u32_less_than(list_length(inner_args), 5) {
+                      1 => (0, store(KExprNode.BVar(0))),
+                      _ =>
+                        let a0 = list_lookup(inner_args, 0);
+                        let a1 = list_lookup(inner_args, 1);
+                        let a2 = list_lookup(inner_args, 2);
+                        let a3 = list_lookup(inner_args, 3);
+                        let a4 = list_lookup(inner_args, 4);
+                        match load(a1) {
+                          KExprNode.Lam(motive_dom, _) =>
+                            match load(a2) {
+                              KExprNode.Lam(fdom, fbody) =>
+                                let fproj = store(KExprNode.Proj(
+                                  struct_addr, fidx, fbody));
+                                let false_minor = store(KExprNode.Lam(
+                                  fdom, fproj));
+                                match load(a3) {
+                                  KExprNode.Lam(tdom, tbody) =>
+                                    let tproj = store(KExprNode.Proj(
+                                      struct_addr, fidx, tbody));
+                                    let true_minor = store(KExprNode.Lam(
+                                      tdom, tproj));
+                                    let nat_ty = store(KExprNode.Const(
+                                      nat_ty_addr(), store(ListNode.Nil)));
+                                    let new_motive = store(KExprNode.Lam(
+                                      motive_dom, nat_ty));
+                                    let head_const = store(KExprNode.Const(
+                                      rec_addr, rec_us));
+                                    let r1 = store(KExprNode.App(head_const, a0));
+                                    let r2 = store(KExprNode.App(r1, new_motive));
+                                    let r3 = store(KExprNode.App(r2, false_minor));
+                                    let r4 = store(KExprNode.App(r3, true_minor));
+                                    let r5 = store(KExprNode.App(r4, a4));
+                                    let post = list_drop(inner_args, 5);
+                                    (1, apply_spine(r5, post)),
+                                  _ => (0, store(KExprNode.BVar(0))),
+                                },
+                              _ => (0, store(KExprNode.BVar(0))),
+                            },
+                          _ => (0, store(KExprNode.BVar(0))),
+                        },
+                    },
+                },
+              _ => (0, store(KExprNode.BVar(0))),
+            },
+          _ => (0, store(KExprNode.BVar(0))),
         },
-      KConstantInfo.Quot(_, _, kind) =>
-        let qiota = try_quot_iota(kind, spine, types, top, addrs);
-        match qiota {
-          (1, reduced_q) => whnf(reduced_q, types, top, addrs),
-          (0, _) => apply_spine(head, spine),
+    }
+  }
+
+  -- Returns the Ctor KCI if `head` is a Const of a Ctor, else a stub axiom
+  -- KCI (harmless — the caller falls through on the non-Ctor match).
+  fn whnf_get_ctor_or_none(head: KExpr) -> &KConstantInfo {
+    match load(head) {
+      KExprNode.Const(addr, _) => get_ci(addr),
+      _ =>
+        store(KConstantInfo.Axiom(0, store(KExprNode.Srt(store(KLevelNode.Zero))), 0)),
+    }
+  }
+
+  -- Const head: delta-unfold Defn or iota-reduce Rec applied to Ctor
+  -- major. Ctor/Ind/Axiom/Quot etc. stay stuck. Before Defn delta, try
+  -- projection-definition shortcut: `def field := fun x => Prj S i x`
+  -- rewrites `field arg` to `Prj S i arg` without expanding the body.
+  -- WHNF each spine arg (needed before calling nat dispatch — args
+  -- must be normalized to Lit/Const-headed forms for try_extract_nat).
+  fn whnf_spine(spine: List‹KExpr›, types: List‹KExpr›) -> List‹KExpr› {
+    match load(spine) {
+      ListNode.Nil => store(ListNode.Nil),
+      ListNode.Cons(a, rest) =>
+        let aw = whnf(a, types);
+        store(ListNode.Cons(aw, whnf_spine(rest, types))),
+    }
+  }
+
+  -- Pre-whnf wrapper for nat dispatch: whnfs unary/binop args first
+  -- (2 first args or 1 first arg for succ/pred), then calls
+  -- try_nat_dispatch.
+  fn try_nat_dispatch_prewhnf(head_addr: Addr, spine: List‹KExpr›,
+                                    types: List‹KExpr›) -> (G, KExpr) {
+    let spine_w = whnf_spine(spine, types);
+    try_nat_dispatch(head_addr, spine_w, types)
+  }
+
+  -- Address-keyed primitive dispatch. Runs BEFORE KConstantInfo
+  -- discrimination so it fires regardless of whether the primitive
+  -- lives as Defn/Axiom/etc. in the loaded env (matters for
+  -- String.utf8ByteSize / String.append which may compile as Defn
+  -- with an external body or as Axiom).
+  -- For BitVec.toNat: whnf spine[1] (the val, expected to be
+  -- BitVec.ofNat W N form) then further whnf its inner args (W and N)
+  -- so try_extract_nat sees Lit(Nat) even when the source used
+  -- OfNat.ofNat wrappers.
+  fn bitvec_prep_spine(spine: List‹KExpr›, types: List‹KExpr›)
+                            -> List‹KExpr› {
+    let spine_w = whnf_spine(spine, types);
+    match load(spine_w) {
+      ListNode.Nil => spine_w,
+      ListNode.Cons(width_e, rest) =>
+        match load(rest) {
+          ListNode.Nil => spine_w,
+          ListNode.Cons(val_e, tail) =>
+            match collect_spine(val_e) {
+              (vh, va) =>
+                let va_w = whnf_spine(va, types);
+                let val_e2 = apply_spine(vh, va_w);
+                let width_w = whnf(width_e, types);
+                store(ListNode.Cons(width_w,
+                  store(ListNode.Cons(val_e2, tail)))),
+            },
         },
+    }
+  }
+
+  -- Primitive-family classification (mirror prim_family,
+  -- Primitive.lean:1419): map a Const-head address to the ONE reducer
+  -- family that could fire on it — 0 = none, 1 = nat, 2 = str,
+  -- 3 = bitvec, 4 = native, 5 = decidable. Keyed on the ADDRESS ALONE:
+  -- one memo row per distinct constant address in the run, and the
+  -- inner addr-set chains collapse after each address's first
+  -- occurrence. Replaces running the is_* gauntlet from
+  -- try_prim_dispatch, whose key includes the spine and context —
+  -- 5 wide rows per Const-head whnf, almost all guaranteed misses.
+  fn prim_family(a: Addr) -> G {
+    match is_nat_prim_addr(a) {
+      1 => 1,
       _ =>
-        -- Family-gated primitive dispatch. `prim_family` is keyed on the
-        -- head ADDRESS alone, so it memoizes to one row per distinct
-        -- constant address in the run; at most ONE family reducer is
-        -- then called. The previous form ran every reducer as a gauntlet
-        -- (nat -> str -> bitvec -> native -> decidable), charging 4-6
-        -- wide rows per Const-head whnf for guaranteed misses — the
-        -- families' address sets are mutually disjoint, so the gauntlet
-        -- order never mattered. A family-reducer miss (e.g. `Nat.add` on
-        -- non-literal args) falls through to proj-def/delta exactly as
-        -- the gauntlet's final arm did.
-        let fam = prim_family(head_addr);
-        let attempt = match fam {
-          1 => try_nat_dispatch(head_addr, spine, types, top, addrs),
-          2 => try_str_dispatch(head_addr, head, spine, types, top, addrs),
-          3 => try_bitvec_dispatch(head_addr, spine, types, top, addrs),
-          4 => try_reduce_native(head_addr, spine, types, top, addrs),
-          5 => try_reduce_decidable(head_addr, idx, lvls, spine, types, top, addrs),
-          _ => (0, store(KExprNode.BVar(0))),
-        };
-        match attempt {
-          (1, reduced) => whnf(reduced, types, top, addrs),
-          -- verdict 2: the reducer normalized the term to an already-stuck
-          -- compact form (symbolic Nat offset); return it WITHOUT re-whnf,
-          -- which would loop.
-          (2, stuck) => stuck,
-          (0, _) =>
-            let proj_def_pair = try_reduce_projection_definition(idx, spine, top);
-            match proj_def_pair {
-              (1, reduced_pd) => whnf(reduced_pd, types, top, addrs),
-              (0, _) =>
-                -- Mirror src/ix/kernel/whnf.rs:756-774
-                -- (`delta_unfold_one`): unfold any Defn
-                -- regardless of `ReducibilityHints`. The
-                -- hint is consulted by lazy-delta's
-                -- `delta_rank` for def-eq priority, not
-                -- as a gate on plain whnf delta. Without
-                -- unfolding here, ctor field types
-                -- written via opaque defs (e.g.
-                -- `constType (n α) (n α)`) stay stuck
-                -- and `check_positivity_aug` misclassifies.
-                match ci {
-                  KConstantInfo.Defn(_, _, value, _, _) =>
-                    let body = expr_inst_levels(value, lvls);
-                    whnf_with_spine(body, spine, types, top, addrs),
-                  KConstantInfo.Thm(_, _, _) => apply_spine(head, spine),
-                  _ => apply_spine(head, spine),
+        match is_str_prim_addr(a) {
+          1 => 2,
+          _ =>
+            match is_bitvec_prim_addr(a) {
+              1 => 3,
+              _ =>
+                match is_native_prim_addr(a) {
+                  1 => 4,
+                  _ =>
+                    match is_dec_prim_addr(a) {
+                      1 => 5,
+                      _ => 0,
+                    },
                 },
             },
         },
     }
   }
 
-  -- ============================================================================
-  -- whnf_nd: WHNF without delta-unfolding (`src/ix/kernel/whnf.rs::whnf_no_delta`).
-  --
-  -- Same dispatch tree as `whnf`, but `whnf_nd_const_head`'s `Defn` arm
-  -- returns the stuck application instead of unfolding. Beta / let zeta /
-  -- iota / proj / quot / primitives still fire — they don't require delta.
-  --
-  -- Used by def_eq's Tier 1d structural pre-check (Rust def_eq.rs:320-326):
-  -- many comparisons settle at no-delta whnf + ptr_eq or structural quick
-  -- comparison, avoiding the cascading delta-unfold work.
-  -- ============================================================================
-  fn whnf_nd(e: KExpr, types: List‹KExpr›,
-             top: List‹&KConstantInfo›, addrs: List‹Addr›) -> KExpr {
-    match load(e) {
-      KExprNode.Srt(_) => e,
-      KExprNode.Lit(_) => e,
-      KExprNode.Lam(_, _) => e,
-      KExprNode.Forall(_, _) => e,
-      KExprNode.BVar(_) => e,
-      _ => whnf_nd_core(e, ctx_trim(types, expr_lbr(e)), top, addrs),
+  fn try_prim_dispatch(addr: Addr, lvls: List‹KLevel›,
+                            spine: List‹KExpr›,
+                            types: List‹KExpr›) -> (G, KExpr) {
+    let fam = prim_family(addr);
+    match fam {
+      1 => try_nat_dispatch_prewhnf(addr, spine, types),
+      2 =>
+        let spine_w = whnf_spine(spine, types);
+        try_str_dispatch(addr, spine_w, types),
+      3 => try_bitvec_dispatch(addr, spine, types),
+      4 => try_native_dispatch(addr, spine, types),
+      5 => try_dec_dispatch(addr, lvls, spine, types),
+      _ => (0, store(KExprNode.BVar(0))),
     }
   }
 
-  fn whnf_nd_core(e: KExpr, types: List‹KExpr›,
-                  top: List‹&KConstantInfo›, addrs: List‹Addr›) -> KExpr {
-    let pair = collect_spine(e);
-    match pair {
-      (head, spine) => whnf_nd_with_spine(head, spine, types, top, addrs),
+  -- Quot iota: Quot.lift α r β f sound (Quot.mk α' r' a) = f a
+  -- and Quot.ind α r motive m (Quot.mk α' r' a) = m a. Fires only for
+  -- Lift/Ind kinds. Ctor/Typ stay stuck.
+  fn try_quot_iota(kind: QuotKind, spine: List‹KExpr›,
+                         types: List‹KExpr›) -> (G, KExpr) {
+    match kind {
+      QuotKind.Lift => try_quot_lift(spine, types),
+      QuotKind.Ind => try_quot_ind(spine, types),
+      _ => (0, store(KExprNode.BVar(0))),
     }
   }
 
-  fn whnf_nd_with_spine(head: KExpr, spine: List‹KExpr›, types: List‹KExpr›,
-                         top: List‹&KConstantInfo›, addrs: List‹Addr›) -> KExpr {
-    match load(head) {
-      KExprNode.App(f, a) =>
-        match collect_spine(head) {
-          (inner_head, inner_spine) =>
-            whnf_nd_with_spine(inner_head, list_concat(inner_spine, spine), types, top, addrs),
+  fn try_quot_lift(spine: List‹KExpr›, types: List‹KExpr›) -> (G, KExpr) {
+    let n = list_length(spine);
+    match u32_less_than(n, 6) {
+      1 => (0, store(KExprNode.BVar(0))),
+      _ =>
+        let f = list_lookup(spine, 3);
+        let q = list_lookup(spine, 5);
+        match quot_extract_arg(q, types) {
+          (1, a) =>
+            let post = list_drop(spine, 6);
+            (1, apply_spine(store(KExprNode.App(f, a)), post)),
+          _ => (0, store(KExprNode.BVar(0))),
         },
-      KExprNode.Lam(ty, body) =>
-        whnf_nd_apply_beta(spine, head, types, top, addrs),
-      KExprNode.Const(idx, lvls) =>
-        whnf_nd_const_head(idx, lvls, head, spine, types, top, addrs),
-      KExprNode.Let(_, val, body) =>
-        let next = expr_inst1(body, val, 0);
-        whnf_nd_with_spine(next, spine, types, top, addrs),
-      KExprNode.Proj(tidx, fidx, inner) =>
-        whnf_nd_proj_head(tidx, fidx, inner, spine, types, top, addrs),
-      _ => apply_spine(head, spine),
     }
   }
 
-  fn whnf_nd_apply_beta(spine: List‹KExpr›, lam: KExpr, types: List‹KExpr›,
-                         top: List‹&KConstantInfo›, addrs: List‹Addr›) -> KExpr {
-    match peel_beta(lam, spine, store(ListNode.Nil)) {
-      (deep, consumed, rest) =>
-        match list_length(consumed) {
-          0 => apply_spine(lam, spine),
-          1 =>
-            let body2 = expr_inst1(deep, list_lookup(consumed, 0), 0);
-            whnf_nd_with_spine(body2, rest, types, top, addrs),
-          _ =>
-            let body2 = expr_inst_many(deep, consumed, 0);
-            whnf_nd_with_spine(body2, rest, types, top, addrs),
+  fn try_quot_ind(spine: List‹KExpr›, types: List‹KExpr›) -> (G, KExpr) {
+    let n = list_length(spine);
+    match u32_less_than(n, 5) {
+      1 => (0, store(KExprNode.BVar(0))),
+      _ =>
+        let m = list_lookup(spine, 3);
+        let q = list_lookup(spine, 4);
+        match quot_extract_arg(q, types) {
+          (1, a) =>
+            let post = list_drop(spine, 5);
+            (1, apply_spine(store(KExprNode.App(m, a)), post)),
+          _ => (0, store(KExprNode.BVar(0))),
         },
     }
   }
 
-  fn whnf_nd_proj_head(tidx: G, fidx: G, inner: KExpr, spine: List‹KExpr›,
-                        types: List‹KExpr›, top: List‹&KConstantInfo›, addrs: List‹Addr›) -> KExpr {
-    let inner_whnf = whnf_nd(inner, types, top, addrs);
-    -- Same Str-literal re-expansion as `whnf_proj_head`.
-    let inner_exp = str_lit_to_ctor_app_or_self(inner_whnf, types, top, addrs);
-    let inner_pair = collect_spine(inner_exp);
-    match inner_pair {
-      (inner_head, inner_args) =>
-        let fvd_pair = try_reduce_fin_val_decidable_rec(tidx, fidx, inner_head, inner_args, addrs);
-        match fvd_pair {
-          (1, rewritten) => whnf_nd_with_spine(rewritten, spine, types, top, addrs),
-          (0, _) =>
-            match load(inner_head) {
-              KExprNode.Const(cidx, _) =>
-                let cci = load(list_lookup(top, cidx));
-                match cci {
-                  KConstantInfo.Ctor(_, _, _, _, nparams, _, _) =>
-                    let field = list_lookup_or_nil(inner_args, nparams + fidx);
-                    whnf_nd_with_spine(field, spine, types, top, addrs),
-                  _ =>
-                    let stuck = store(KExprNode.Proj(tidx, fidx, inner_whnf));
-                    apply_spine(stuck, spine),
+  -- WHNF q; if q reduces to `App-spine(Const(Quot.mk), [α, r, a])`,
+  -- return (1, a). Else (0, _).
+  fn quot_extract_arg(q: KExpr, types: List‹KExpr›) -> (G, KExpr) {
+    let q_w = whnf(q, types);
+    match collect_spine(q_w) {
+      (head, args) =>
+        match load(head) {
+          KExprNode.Const(caddr, _) =>
+            let ci = load(get_ci(caddr));
+            match ci {
+              KConstantInfo.Quot(_, _, kind) =>
+                match kind {
+                  QuotKind.Ctor =>
+                    match list_length(args) - 3 {
+                      0 => (1, list_lookup(args, 2)),
+                      _ => (0, store(KExprNode.BVar(0))),
+                    },
+                  _ => (0, store(KExprNode.BVar(0))),
                 },
-              _ =>
-                let stuck = store(KExprNode.Proj(tidx, fidx, inner_whnf));
-                apply_spine(stuck, spine),
+              _ => (0, store(KExprNode.BVar(0))),
             },
+          _ => (0, store(KExprNode.BVar(0))),
         },
     }
   }
 
-  -- The difference from `whnf_const_head`: Defn arm returns stuck instead of
-  -- unfolding. Iota, quot, primitives, proj-defs still apply.
-  fn whnf_nd_const_head(idx: G, lvls: List‹KLevel›, head: KExpr, spine: List‹KExpr›,
-                         types: List‹KExpr›, top: List‹&KConstantInfo›, addrs: List‹Addr›) -> KExpr {
-    let head_addr = list_lookup(addrs, idx);
-    let ci = load(list_lookup(top, idx));
+  -- Const-head WHNF dispatch, split out of `whnf_with_spine` (see its Const arm).
+  -- `head` is the original `Const(idx, lvls)` KExpr, passed for the stuck
+  -- `apply_spine(head, spine)` fallbacks.
+  fn whnf_const_head(addr: Addr, lvls: List‹KLevel›, head: KExpr,
+                         spine: List‹KExpr›, types: List‹KExpr›) -> KExpr {
+    let prim = try_prim_dispatch(addr, lvls, spine, types);
+    match prim {
+      (1, reduced) => whnf(reduced, types),
+      -- verdict 2: the reducer normalized the term to an already-stuck
+      -- compact form (symbolic Nat offset); return it WITHOUT re-whnf
+      -- and WITHOUT falling to the Defn arm — delta-unfolding it would
+      -- expand a succ^n tower / the division algorithm. Mirror
+      -- whnf_const_head:230.
+      (2, stuck) => stuck,
+      _ =>
+    let ci = load(get_ci(addr));
     match ci {
-      KConstantInfo.Rec(num_lvls, _, num_params, num_indices, num_motives, num_minors, rules, k_flag, _, _) =>
-        let iota = try_iota(lvls, spine, num_lvls, num_params, num_indices, num_motives, num_minors, rules, k_flag, types, top, addrs);
-        match iota {
-          (1, reduced2) => whnf_nd(reduced2, types, top, addrs),
-          (0, _) => apply_spine(head, spine),
+      KConstantInfo.Defn(_, _, value, _, _) =>
+        let pd = try_reduce_projection_definition(value, spine);
+        match pd {
+          (1, reduced) => whnf(reduced, types),
+          _ =>
+            let body = expr_inst_levels(value, lvls);
+            whnf_with_spine(body, spine, types),
         },
+      -- Thm stays stuck in whnf (mirror Whnf.lean:250 / Rust): proof
+      -- bodies unfold only through lazy-delta's try_unfold_head, so
+      -- proof_irrel / congruence get first shot at Thm-headed pairs.
+      KConstantInfo.Thm(_, _, _) => apply_spine(head, spine),
       KConstantInfo.Quot(_, _, kind) =>
-        let qiota = try_quot_iota(kind, spine, types, top, addrs);
-        match qiota {
-          (1, reduced_q) => whnf_nd(reduced_q, types, top, addrs),
-          (0, _) => apply_spine(head, spine),
+        let quot = try_quot_iota(kind, spine, types);
+        match quot {
+          (1, reduced) => whnf(reduced, types),
+          _ => apply_spine(head, spine),
         },
-      _ =>
-        -- Family-gated primitive dispatch, same as `whnf_const_head`.
-        let fam = prim_family(head_addr);
-        let attempt = match fam {
-          1 => try_nat_dispatch(head_addr, spine, types, top, addrs),
-          2 => try_str_dispatch(head_addr, head, spine, types, top, addrs),
-          3 => try_bitvec_dispatch(head_addr, spine, types, top, addrs),
-          4 => try_reduce_native(head_addr, spine, types, top, addrs),
-          5 => try_reduce_decidable(head_addr, idx, lvls, spine, types, top, addrs),
-          _ => (0, store(KExprNode.BVar(0))),
-        };
-        match attempt {
-          (1, reduced) => whnf_nd(reduced, types, top, addrs),
-          -- verdict 2: already-stuck compact form; do not re-whnf.
-          (2, stuck) => stuck,
-          (0, _) =>
-            let proj_def_pair = try_reduce_projection_definition(idx, spine, top);
-            match proj_def_pair {
-              (1, reduced_pd) => whnf_nd(reduced_pd, types, top, addrs),
-              (0, _) =>
-                -- Defn / Thm / etc.: STUCK in no-delta mode. The whole point.
-                apply_spine(head, spine),
+      KConstantInfo.Rec(nlvls, rec_ty, nparams, nindices, nmotives, nminors,
+                          rules, k_flag, _unsafe, _block, _ridx) =>
+        let iota = try_iota(lvls, spine, nparams, nmotives, nminors,
+                                 nindices, rules, types, head,
+                                 rec_to_parent_addr(rec_ty, nparams, nmotives,
+                                   nminors, nindices));
+        match iota {
+          (1, reduced) => whnf(reduced, types),
+          (2, stuck) =>
+            -- K-recursor synth fallback (): when major stuck and
+            -- k_flag=1, fire rule[0] assuming the nullary K-ctor
+            -- (Eq.refl, HEq.refl, etc.) — GATED like Lean's
+            -- toCtorWhenK: the major's inferred type must be
+            -- this recursor's inductive with indices def-eq to the
+            -- synthesized ctor app's. Ungated firing strips Eq.rec
+            -- transports whose endpoints differ symbolically, yielding
+            -- mistyped reducts.
+            match k_flag {
+              1 =>
+                -- The recursor's OWN inductive, read from its declared
+                -- major premise. The K gate must check the major's
+                -- inferred inductive against this — comparing the major
+                -- against its own inductive's ctor is vacuous, and would
+                -- strip an `I.rec` over a major of some other inductive
+                -- `J`. (This is an inductive-addr comparison, not a
+                -- `block`-field one, so the solo-wrapper mismatch noted in
+                -- k_synth_gate does not apply.)
+                let k_skip = ((nparams + nmotives) + nminors) + nindices;
+                match se_parent_addr(rec_ty, k_skip) {
+                  (_, rec_parent) =>
+                    try_k_synth_iota(lvls, spine, nparams, nmotives,
+                                        nminors, nindices, rules, stuck,
+                                        rec_parent, types),
+                },
+              _ =>
+                -- Struct-eta iota (mirror try_struct_eta_iota /
+                -- Rust whnf.rs:1244 / Lean toCtorWhenStructure): major
+                -- stuck but inductive is a structure (1 ctor, 0
+                -- indices, non-recursive, non-Prop major) → synthesize
+                -- the ctor app from field projections of the major and
+                -- fire the single rule anyway.
+                match try_struct_eta_iota(rec_ty, lvls, spine, nparams,
+                        nmotives, nminors, nindices, rules, types) {
+                  (1, r) => whnf(r, types),
+                  _ => stuck,
+                },
             },
+          _ => apply_spine(head, spine),
         },
+      _ => apply_spine(head, spine),
+    },
     }
   }
 
-  -- No fuel limit (unlike Rust's `MAX_WHNF_FUEL = 10_000` in
-  -- `src/ix/kernel/tc.rs`). In a zk prover context, divergent input simply
-  -- fails to produce a proof — the caller guarantees termination, so a
-  -- soundness-preserving early abort is unnecessary.
-  fn whnf(e: KExpr, types: List‹KExpr›,
-          top: List‹&KConstantInfo›, addrs: List‹Addr›) -> KExpr {
-    -- Fast path: trivial whnf normal forms. Srt / Lit / Lam / Forall / BVar
-    -- never reduce — skip collect_spine + dispatch (and the context trim).
-    match load(e) {
-      KExprNode.Srt(_) => e,
-      KExprNode.Lit(_) => e,
-      KExprNode.Lam(_, _) => e,
-      KExprNode.Forall(_, _) => e,
-      KExprNode.BVar(_) => e,
-      -- Context-trimmed memo key (mirror Rust `whnf_key`): reduce on the
-      -- reachable suffix so a closed term shares its WHNF across binder depths.
-      _ => whnf_core(e, ctx_trim(types, expr_lbr(e)), top, addrs),
+  -- Recognize `λ x_1 ... x_n → Prj S i (BVar k)` and rewrite an
+  -- application of the constant to a direct Prj. Mirrors the Rust
+  -- implementation in crates/kernel/src. Pure perf — standard
+  -- delta+beta produces the same result — but keeps binder-type WHNF
+  -- inside a proj scrutinee stuck at Const-inductive form rather than
+  -- descending into the body and getting stuck at a partially-applied
+  -- Lam.
+  fn try_reduce_projection_definition(value: KExpr,
+                                          spine: List‹KExpr›) -> (G, KExpr) {
+    match projection_definition_info(value, 0) {
+      (1, arity, struct_addr, field, struct_arg_idx) =>
+        match u32_less_than(list_length(spine), arity) {
+          1 => (0, store(KExprNode.BVar(0))),
+          _ =>
+            let target_arg = list_lookup(spine, struct_arg_idx);
+            let proj_expr = store(KExprNode.Proj(struct_addr, field, target_arg));
+            let post = list_drop(spine, arity);
+            (1, apply_spine(proj_expr, post)),
+        },
+      _ => (0, store(KExprNode.BVar(0))),
     }
   }
 
-  fn whnf_core(e: KExpr, types: List‹KExpr›,
-               top: List‹&KConstantInfo›, addrs: List‹Addr›) -> KExpr {
-    let pair = collect_spine(e);
-    match pair {
-      (head, spine) => whnf_with_spine(head, spine, types, top, addrs),
+  -- Returns (found, arity, struct_addr, field, struct_arg_idx). Walks
+  -- Lam bindings counting arity; expects body to be `Prj S i (BVar k)`
+  -- with `k < arity`. struct_arg_idx = (arity - 1) - k.
+  fn projection_definition_info(val: KExpr, arity: G)
+                                    -> (G, G, Addr, G, G) {
+    match load(val) {
+      KExprNode.Lam(_, body) =>
+        projection_definition_info(body, arity + 1),
+      KExprNode.Proj(struct_addr, field, projected) =>
+        match load(projected) {
+          KExprNode.BVar(i) =>
+            match u32_less_than(i, arity) {
+              1 => (1, arity, struct_addr, field, (arity - 1) - i),
+              _ => (0, 0, store([0u8; 32]), 0, 0),
+            },
+          _ => (0, 0, store([0u8; 32]), 0, 0),
+        },
+      _ => (0, 0, store([0u8; 32]), 0, 0),
     }
   }
 
-  -- ============================================================================
-  -- Iota (recursor on ctor)
-  -- ============================================================================
-  fn try_iota(lvls: List‹KLevel›, spine: List‹KExpr›,
-              num_lvls: G, num_params: G, num_indices: G,
-              num_motives: G, num_minors: G,
-              rules: List‹KRecRule›, k_flag: G, types: List‹KExpr›,
-              top: List‹&KConstantInfo›, addrs: List‹Addr›) -> (G, KExpr) {
-    let major_idx = num_params + num_motives + num_minors + num_indices;
-    let spine_len = list_length(spine);
-    let major_lt = u32_less_than(major_idx, spine_len);
-    match major_lt {
-      0 => (0, store(KExprNode.BVar(0))),
-      1 =>
-        let lvls_len = list_length(lvls);
-        match lvls_len - num_lvls {
-          0 =>
-            try_iota_with_major(lvls, spine, num_params, num_motives, num_minors,
-                                major_idx, rules, k_flag, types, top, addrs),
-          _ => (0, store(KExprNode.BVar(0))),
-        },
-    }
+  -- Canonical Nat.zero / Nat.succ addrs. Mirror
+  -- crates/kernel/src, 490).
+  fn nat_zero_addr_iota() -> Addr {
+    store([0xd3u8, 0x97u8, 0x37u8, 0x01u8, 0x57u8, 0xfbu8, 0x9au8, 0xe2u8,
+     0xc6u8, 0xe1u8, 0xedu8, 0xa7u8, 0x9fu8, 0xebu8, 0x10u8, 0xbfu8,
+     0x49u8, 0x74u8, 0x01u8, 0x74u8, 0x1au8, 0xbau8, 0x78u8, 0x8fu8,
+     0xabu8, 0x72u8, 0x6cu8, 0xfau8, 0x4cu8, 0x46u8, 0x7du8, 0xb6u8])
   }
 
-  -- Mirror src/ix/kernel/whnf.rs:1113-1143 cleanup_nat_offset_major.
-  -- If `e` is `Nat.add base lit` with lit > 0, return one-layer-exposed
-  -- `Nat.succ pred` where pred = base if lit == 1, else `Nat.add base (lit-1)`.
-  -- Else returns `e` unchanged. Skips Nat literals (already evaluable).
-  fn cleanup_nat_offset_major(e: KExpr, addrs: List‹Addr›) -> KExpr {
+  fn nat_succ_addr_iota() -> Addr {
+    store([0xdeu8, 0xf5u8, 0x2du8, 0x1du8, 0xadu8, 0x5fu8, 0x10u8, 0xcfu8,
+     0x98u8, 0x93u8, 0xc9u8, 0x45u8, 0xe1u8, 0x69u8, 0x71u8, 0x8du8,
+     0x62u8, 0xb1u8, 0x5eu8, 0x2du8, 0xd2u8, 0xc9u8, 0x06u8, 0x6eu8,
+     0x59u8, 0x7bu8, 0x9du8, 0x45u8, 0x70u8, 0xbau8, 0x05u8, 0x6eu8])
+  }
+
+  -- Convert `Lit(Nat n)` to `Nat.zero` or `App(Nat.succ, Lit(n-1))`.
+  -- Non-Lit inputs pass through unchanged. Enables iota to fire on
+  -- Lit majors.  Mirror crates/kernel/src.
+  fn nat_lit_to_ctor_or_self(e: KExpr) -> KExpr {
     match load(e) {
-      KExprNode.Lit(_) => e,
-      _ =>
-        match collect_spine(e) {
-          (head, args) =>
-            match load(head) {
-              KExprNode.Const(_, _) =>
-                match try_match_nat_add(head, args, addrs) {
-                  (1, base, lit) =>
-                    let lit_norm = klimbs_normalize(lit);
-                    match klimbs_is_zero(lit_norm) {
-                      1 => e,
-                      0 => build_succ_offset(base, lit_norm, addrs),
-                    },
-                  _ => e,
-                },
-              _ => e,
+      KExprNode.Lit(lit) =>
+        match lit {
+          KLiteral.Nat(klimbs) =>
+            match klimbs_is_zero(klimbs) {
+              1 => store(KExprNode.Const(nat_zero_addr_iota(),
+                                          store(ListNode.Nil))),
+              _ =>
+                let pred_limbs = klimbs_normalize(klimbs_dec(klimbs));
+                let pred = store(KExprNode.Lit(KLiteral.Nat(pred_limbs)));
+                let succ_const = store(KExprNode.Const(nat_succ_addr_iota(),
+                                                       store(ListNode.Nil)));
+                store(KExprNode.App(succ_const, pred)),
             },
+          _ => e,
         },
+      _ => e,
     }
   }
 
-  -- If head is Const(nat_add) and args has length 2 and args[1] is Lit Nat,
-  -- return (1, base, limbs). Else (0, _, _).
-  fn try_match_nat_add(head: KExpr, args: List‹KExpr›,
-                       addrs: List‹Addr›) -> (G, KExpr, KLimbs) {
-    match load(head) {
-      KExprNode.Const(idx, _) =>
-        let head_addr = list_lookup(addrs, idx);
-        match address_eq(head_addr, nat_add_addr()) {
-          0 => (0, head, store(ListNode.Nil)),
-          1 =>
-            match list_length(args) - 2 {
-              0 =>
-                let lhs = list_lookup(args, 0);
-                let rhs = list_lookup(args, 1);
-                match load(rhs) {
-                  KExprNode.Lit(lit) =>
-                    match lit {
-                      KLiteral.Nat(limbs) => (1, lhs, limbs),
-                      _ => (0, head, store(ListNode.Nil)),
-                    },
-                  _ => (0, head, store(ListNode.Nil)),
-                },
-              _ => (0, head, store(ListNode.Nil)),
+  -- K-recursor synth: fire rule[0] assuming the nullary K-ctor, but only
+  -- when the toCtorWhenK gate holds (mirror try_synth_k_ctor,
+  -- crates/kernel/src: infer the major's type, require its
+  -- head to be this recursor's inductive, synthesize the ctor app from
+  -- the type's params, and require def_eq(major_ty, ctor_ty). Without
+  -- the gate, an Eq.rec transport whose endpoints differ symbolically
+  -- gets stripped, producing mistyped reducts.
+  fn try_k_synth_iota(lvls: List‹KLevel›, spine: List‹KExpr›,
+                          nparams: G, nmotives: G, nminors: G, nindices: G,
+                          rules: List‹KRecRule›, stuck: KExpr,
+                          rec_parent: Addr, types: List‹KExpr›) -> KExpr {
+    match load(rules) {
+      ListNode.Cons(r, _) =>
+        match r {
+          KRecRule.Mk(cidx, _rfields, rrhs) =>
+            let major_idx = nparams + nmotives + nminors + nindices;
+            let raw_major = list_lookup(spine, major_idx);
+            match k_synth_gate(raw_major, cidx, nparams, rec_parent, types) {
+              0 => stuck,
+              _ =>
+                let rhs_lvled = expr_inst_levels(rrhs, lvls);
+                let pmm_end = nparams + nmotives + nminors;
+                let pmm = list_take(spine, pmm_end);
+                let post_major = list_drop(spine, major_idx + 1);
+                let r1 = apply_spine(rhs_lvled, pmm);
+                let r3 = apply_spine(r1, post_major);
+                whnf(r3, types),
             },
         },
-      _ => (0, head, store(ListNode.Nil)),
+      _ => stuck,
     }
   }
 
-  -- Build `Nat.succ pred` where pred = base if lit==1, else `Nat.add base (lit-1)`.
-  fn build_succ_offset(base: KExpr, lit: KLimbs,
-                       addrs: List‹Addr›) -> KExpr {
-    let succ_pair = find_addr_idx_safe(nat_succ_addr(), addrs, 0);
-    match succ_pair {
-      (0, _) => store(KExprNode.App(base, base)), -- impossible: Nat.succ must be in env
-      (1, succ_idx) =>
-        let one = store(ListNode.Cons([1u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], store(ListNode.Nil)));
-        let lit_minus_one = klimbs_sub(lit, one);
-        let pred_lit_norm = klimbs_normalize(lit_minus_one);
-        let succ_const = store(KExprNode.Const(succ_idx, store(ListNode.Nil)));
-        match klimbs_is_zero(pred_lit_norm) {
-          1 => store(KExprNode.App(succ_const, base)),
-          0 =>
-            let add_pair = find_addr_idx_safe(nat_add_addr(), addrs, 0);
-            match add_pair {
-              (0, _) => store(KExprNode.App(succ_const, base)),
-              (1, add_idx) =>
-                let add_const = store(KExprNode.Const(add_idx, store(ListNode.Nil)));
-                let pred_lit_expr = store(KExprNode.Lit(KLiteral.Nat(pred_lit_norm)));
-                let pred = store(KExprNode.App(
-                  store(KExprNode.App(add_const, base)),
-                  pred_lit_expr));
-                store(KExprNode.App(succ_const, pred)),
+  -- The toCtorWhenK gate: 1 iff whnf(infer(major)) is `I params indices`
+  -- for this recursor's own inductive AND the synthesized ctor app
+  -- `I.ctor params` has type def-eq to the major's. Mirror
+  -- try_synth_k_ctor's verification step.
+  fn k_synth_gate(raw_major: KExpr, cidx: G, nparams: G,
+                      rec_parent: Addr, types: List‹KExpr›) -> G {
+    let major_ty = k_infer(raw_major, types);
+    let major_ty_w = whnf(major_ty, types);
+    match collect_spine(major_ty_w) {
+      (ty_head, ty_args) =>
+        match load(ty_head) {
+          KExprNode.Const(ind_addr, ctor_us) =>
+            -- Identity: the major's inductive must be the recursor's own.
+            -- Everything below is derived from the major, so without this
+            -- the def_eq compares the major against its OWN inductive's
+            -- ctor and always holds — vacuous. `rec_parent` is the
+            -- inductive named in the recursor's declared major premise, so
+            -- this is an inductive-addr comparison, not the `block`-field
+            -- comparison the solo-wrapper case breaks.
+            match address_eq(ind_addr, rec_parent) {
+              0 => 0,
+              _ =>
+                let ind_ci = load(get_ci(ind_addr));
+                match ind_ci {
+                  KConstantInfo.Induct(_, _, _, _, _, _, ind_block, ind_idx) =>
+                    let cprj = canon_cprj_addr(ind_block, ind_idx, cidx);
+                    let ctor_head = store(KExprNode.Const(cprj, ctor_us));
+                    let params = list_take(ty_args, nparams);
+                    let ctor_app = apply_spine(ctor_head, params);
+                    let ctor_ty = k_infer(ctor_app, types);
+                    k_is_def_eq(major_ty_w, ctor_ty, types),
+                  _ => 0,
+                },
             },
+          _ => 0,
         },
     }
   }
 
-  fn try_iota_with_major(lvls: List‹KLevel›, spine: List‹KExpr›,
-                         num_params: G, num_motives: G, num_minors: G,
-                         major_idx: G, rules: List‹KRecRule›, k_flag: G,
-                         types: List‹KExpr›,
-                         top: List‹&KConstantInfo›, addrs: List‹Addr›) -> (G, KExpr) {
-    -- Mirror: src/ix/kernel/whnf.rs:1824-1869 try_reduce_nat_succ_linear_rec.
-    -- Fast path: `Nat.rec _ base (λ _ ih => succ ih) (Lit n)` → `base + n`.
-    -- O(1) instead of O(n) iota expansion of literal succ chain.
-    let lin = try_nat_linear_rec(spine, num_params, num_motives, num_minors,
-                                  major_idx, types, top, addrs);
-    match lin {
-      (1, r) => (1, r),
-      (0, _) =>
-    let raw_major = list_lookup(spine, major_idx);
-    -- K-target shortcut: when recursor's k_flag is set, attempt to
-    -- synthesize a nullary ctor application from the spine's params,
-    -- enabling iota even when the major isn't reduced to a Ctor.
-    -- Mirror: src/ix/kernel/whnf.rs:1315-1380 synth_ctor_when_k.
-    let major = match k_flag {
-      1 =>
-        let synth = try_synth_k_ctor(raw_major, num_params, rules,
-                                     types, top, addrs);
-        match synth {
-          (1, ctor_app) => ctor_app,
-          (0, _) => raw_major,
-        },
-      0 => raw_major,
-    };
-    -- Pre-WHNF cleanup: if major is `Nat.add base lit` with lit > 0, expose
-    -- one Nat.succ layer to enable iota without unfolding Nat.add into a
-    -- chain of `lit` intermediate literals. Mirror whnf.rs:904-907,1113-1143
-    -- cleanup_nat_offset_major.
-    let major_clean1 = cleanup_nat_offset_major(major, addrs);
-    let major_whnf_raw = whnf(major_clean1, types, top, addrs);
-    let major_clean2 = cleanup_nat_offset_major(major_whnf_raw, addrs);
-    -- Coerce Nat / Str literals to ctor chain so iota fires (mirror
-    -- whnf.rs nat coercion + str_lit_to_ctor_app: the Str expansion
-    -- takes one delta step past `String.ofList` where it is a Defn, so
-    -- the head is the real constructor and the native ofList collapse
-    -- cannot fold the expansion straight back into the literal).
-    let major_whnf_nat = nat_lit_to_ctor_or_self(major_clean2, addrs);
-    let major_whnf = str_lit_to_ctor_app_or_self(major_whnf_nat, types, top, addrs);
-    let major_pair = collect_spine(major_whnf);
-    match major_pair {
-      (ctor_head, ctor_args) =>
-        match load(ctor_head) {
-          KExprNode.Const(ctor_idx, _) =>
-            let ctor_ci = load(list_lookup(top, ctor_idx));
-            match ctor_ci {
-              KConstantInfo.Ctor(_, _, _, cidx, _, ctor_nfields, _) =>
-                let rules_len = list_length(rules);
-                let cidx_in_range = u32_less_than(cidx, rules_len);
-                match cidx_in_range {
-                  0 => (0, store(KExprNode.BVar(0))),
-                  1 =>
-                    let ctor_args_len = list_length(ctor_args);
-                    let too_few_fields = u32_less_than(ctor_args_len, ctor_nfields);
-                    match too_few_fields {
-                      1 => (0, store(KExprNode.BVar(0))),
-                      0 =>
-                        let rule = list_lookup(rules, cidx);
-                        match rule {
-                          KRecRule.Mk(_, _, rhs) =>
-                            let pmm_end = num_params + num_motives + num_minors;
-                            let pmm = list_take(spine, pmm_end);
-                            let field_start = ctor_args_len - ctor_nfields;
-                            let field_args = list_drop(ctor_args, field_start);
-                            let post_major = list_drop(spine, major_idx + 1);
-                            let rhs_inst = expr_inst_levels(rhs, lvls);
-                            let r1 = apply_spine(rhs_inst, pmm);
-                            let r2 = apply_spine(r1, field_args);
-                            let r3 = apply_spine(r2, post_major);
-                            (1, r3),
-                        },
-                    },
-                },
-              _ =>
-                -- Not a Ctor; fall through to struct-eta-iota.
-                try_struct_eta_iota(spine, num_params, num_motives, num_minors,
-                                    major_idx, rules, lvls, types, top, addrs),
+  -- Attempt iota reduction: given a recursor head + spine, whnf the
+  -- major argument. If it's a Ctor application matching one of the
+  -- rules, apply the rule's rhs (Lam-wrapped) to
+  -- params ++ motives ++ minors ++ ctor_fields ++ post_major via
+  -- apply_spine so that outer whnf beta-reduces. Mirror
+  -- crates/kernel/src.
+  -- Rewrite spine with major (at major_idx) replaced by given whnf'd major.
+  fn replace_spine_major(spine: List‹KExpr›, major_idx: G, major_w: KExpr)
+                             -> List‹KExpr› {
+    let pre = list_take(spine, major_idx);
+    let post = list_drop(spine, major_idx + 1);
+    let with_major = list_concat(pre,
+      store(ListNode.Cons(major_w, store(ListNode.Nil))));
+    list_concat(with_major, post)
+  }
+
+  -- Status codes returned by try_iota:
+  --   1 = fired, use returned expr as reduced form (re-whnf)
+  --   2 = stuck with major whnf'd, returned expr is the canonical
+  --       stuck form — caller MUST NOT re-whnf (would infinite loop)
+  --   0 = stuck without major work (major_idx >= spine_len)
+  fn try_iota(lvls: List‹KLevel›, spine: List‹KExpr›,
+                  nparams: G, nmotives: G, nminors: G, nindices: G,
+                  rules: List‹KRecRule›, types: List‹KExpr›,
+                  head: KExpr, rec_parent: Addr) -> (G, KExpr) {
+    let major_idx = nparams + nmotives + nminors + nindices;
+    let spine_len = list_length(spine);
+    match u32_less_than(major_idx, spine_len) {
+      0 => (0, store(KExprNode.BVar(0))),
+      _ =>
+        --  linear-rec fast path: `Nat.rec base (fun _ ih => succ ih) (Lit n)`
+        -- collapses in O(1) to base+n / stuck offset, avoiding n iota expansions.
+        let lin = try_nat_linear_rec(spine, nparams, nmotives, nminors, major_idx);
+        match lin {
+          (1, r) => (1, r),
+          _ =>
+        let raw_major = list_lookup(spine, major_idx);
+        --  cleanup: expose one Nat.succ layer if major is
+        -- `Nat.add base (Lit n)` with n>0, so iota can fire without
+        -- unfolding into n unary succs.
+        let major_clean1 = cleanup_nat_offset_major(raw_major);
+        let major_w = whnf(major_clean1, types);
+        let major_clean2 = cleanup_nat_offset_major(major_w);
+        let major = nat_lit_to_ctor_or_self(major_clean2);
+        match collect_spine_of_ctor(major) {
+          (1, ctor_cidx, ctor_parent, ctor_args) =>
+            -- The constructor must belong to the inductive THIS recursor
+            -- eliminates. Rules are otherwise selected by index alone, so
+            -- any inductive's constructor with a matching index fires a
+            -- rule and the redex reduces to a branch of an unrelated
+            -- eliminator. Lean matches on the constructor's name, which
+            -- pins the inductive; this is the addr-first equivalent.
+            --
+            -- `rec_to_parent_addr` reads the parent off the recursor's
+            -- own type (the major premise's head), and Aiur memoizes it
+            -- per argument tuple, so the walk is paid once per recursor
+            -- rather than once per reduction.
+            assert_eq!(address_eq(ctor_parent, rec_parent), 1,
+              "iota: major's constructor belongs to a different inductive");
+            let rule = find_rule(rules, ctor_cidx);
+            match rule {
+              (0, _, _) =>
+                -- No rule for this ctor — rebuild stuck with whnf'd major.
+                let new_spine = replace_spine_major(spine, major_idx, major_w);
+                (2, apply_spine(head, new_spine)),
+              (1, rfields, rrhs) =>
+                let rhs_lvled = expr_inst_levels(rrhs, lvls);
+                let pmm_end = nparams + nmotives + nminors;
+                let pmm = list_take(spine, pmm_end);
+                let ctor_fields_len = list_length(ctor_args);
+                let field_start = ctor_fields_len - rfields;
+                let field_args = list_drop(ctor_args, field_start);
+                let post_major = list_drop(spine, major_idx + 1);
+                let r1 = apply_spine(rhs_lvled, pmm);
+                let r2 = apply_spine(r1, field_args);
+                let r3 = apply_spine(r2, post_major);
+                (1, r3),
             },
           _ =>
-            -- head not a Const; fall through to struct-eta-iota.
-            try_struct_eta_iota(spine, num_params, num_motives, num_minors,
-                                major_idx, rules, lvls, types, top, addrs),
+            -- Major not a Ctor — stuck, but rebuild spine with whnf'd major
+            -- so downstream def_eq compares against canonical stuck form.
+            let new_spine = replace_spine_major(spine, major_idx, major_w);
+            (2, apply_spine(head, new_spine)),
+        },
         },
-    },
     }
   }
 
-  -- Mirror: src/ix/kernel/whnf.rs:1824-1869 try_reduce_nat_succ_linear_rec.
-  -- Detects `Nat.rec _ base step (Lit n)` with step = `λ _ ih => Nat.succ ih`
-  -- and reduces directly to `Lit (base + n)`. Returns (1, result) on hit,
-  -- (0, _) on miss.
-  fn try_nat_linear_rec(spine: List‹KExpr›, num_params: G, num_motives: G,
-                        num_minors: G, major_idx: G,
-                        types: List‹KExpr›, top: List‹&KConstantInfo›,
-                        addrs: List‹Addr›) -> (G, KExpr) {
-    match u32_less_than(num_minors, 2) {
-      1 => (0, store(KExprNode.BVar(0))),
-      0 =>
-        let raw_major = list_lookup(spine, major_idx);
-        let major_w = whnf(raw_major, types, top, addrs);
-        match try_extract_nat(major_w, addrs) {
-          (0, _) => (0, store(KExprNode.BVar(0))),
-          (1, n_klimbs) =>
-            let base_idx = num_params + num_motives;
-            let raw_step = list_lookup(spine, base_idx + 1);
-            let step_w = whnf(raw_step, types, top, addrs);
-            match is_nat_succ_ih_step(step_w, addrs) {
-              0 => (0, store(KExprNode.BVar(0))),
-              1 =>
-                let raw_base = list_lookup(spine, base_idx);
-                let base_w = whnf(raw_base, types, top, addrs);
-                let post = list_drop(spine, major_idx + 1);
-                match try_extract_nat(base_w, addrs) {
-                  -- Symbolic base: collapse `Nat.rec base (succ-step) (Lit n)`
-                  -- to the offset primitive `Nat.add base (Lit n)` rather than
-                  -- materializing succ^n(base) via n iota steps. This keeps the
-                  -- value in the same compact `base + n` form a literal already
-                  -- has, so def-eq converges instead of descending n unary
-                  -- succ layers (the UTF-8 `x + 0xC0` pathology).
-                  (0, _) => mk_nat_offset_stuck(base_w, n_klimbs, post, addrs),
-                  (1, b_klimbs) =>
-                    (1, apply_spine(mk_nat_lit(klimbs_add(b_klimbs, n_klimbs)), post)),
-                },
+  -- Collect a Ctor application: returns (1, cidx, args) if head is
+  -- Const(ctor_addr) with a Ctor KCI, else (0, 0, []).
+  -- Also returns the constructor's PARENT inductive, as the address of
+  -- its projection wrapper, so the caller can check that the constructor
+  -- actually belongs to the recursor being reduced. Without that, rules
+  -- are selected by index alone and any inductive's constructor with a
+  -- matching index fires a rule. Lean matches on the constructor's name,
+  -- which pins the inductive.
+  fn collect_spine_of_ctor(e: KExpr) -> (G, G, Addr, List‹KExpr›) {
+    match collect_spine(e) {
+      (head, args) =>
+        match load(head) {
+          KExprNode.Const(addr, _) =>
+            let ci = load(get_ci(addr));
+            match ci {
+              KConstantInfo.Ctor(_, _, block_addr, ind_idx, cidx, _, _, _) =>
+                (1, cidx, compute_iprj_addr(block_addr, ind_idx), args),
+              _ => (0, 0, store([0u8; 32]), store(ListNode.Nil)),
             },
+          _ => (0, 0, store([0u8; 32]), store(ListNode.Nil)),
         },
     }
   }
 
-  -- 1 iff `step` whnf-shape is `λ _ (λ _ (Nat.succ #0))`.
-  fn is_nat_succ_ih_step(step: KExpr, addrs: List‹Addr›) -> G {
-    match load(step) {
-      KExprNode.Lam(_, body1) =>
-        match load(body1) {
-          KExprNode.Lam(_, body2) =>
-            match collect_spine(body2) {
-              (head, args) =>
-                match load(head) {
-                  KExprNode.Const(idx, _) =>
-                    let head_addr = list_lookup(addrs, idx);
-                    match address_eq(head_addr, nat_succ_addr()) {
-                      0 => 0,
-                      1 =>
-                        match list_length(args) - 1 {
-                          0 =>
-                            match load(list_lookup(args, 0)) {
-                              KExprNode.BVar(i) => eq_zero(i),
-                              _ => 0,
-                            },
-                          _ => 0,
-                        },
-                    },
-                  _ => 0,
-                },
+  -- Find rule matching cidx: returns (1, nfields, rhs) or (0, 0, ...).
+  fn find_rule(rules: List‹KRecRule›, cidx: G) -> (G, G, KExpr) {
+    match load(rules) {
+      ListNode.Nil => (0, 0, store(KExprNode.BVar(0))),
+      ListNode.Cons(r, rest) =>
+        match r {
+          KRecRule.Mk(rcidx, nfields, rhs) =>
+            match rcidx - cidx {
+              0 => (1, nfields, rhs),
+              _ => find_rule(rest, cidx),
             },
-          _ => 0,
         },
-      _ => 0,
     }
   }
 
-  -- Mirror: src/ix/kernel/whnf.rs:1244-1301 try_struct_eta_iota.
-  -- Fires when major doesn't reduce to ctor BUT inductive is struct-like
-  -- (1 ctor, 0 indices, non-recursive). Synthesizes ctor_app via field
-  -- projections from the major. Refuses on Prop-typed structures (Rust
-  -- whnf.rs:1283 H3 Prop guard via lean4lean toCtorWhenStruct:51).
-  fn try_struct_eta_iota(spine: List‹KExpr›,
-                         num_params: G, num_motives: G, num_minors: G,
-                         major_idx: G, rules: List‹KRecRule›,
-                         lvls: List‹KLevel›, types: List‹KExpr›,
-                         top: List‹&KConstantInfo›, addrs: List‹Addr›) -> (G, KExpr) {
-    let n_rules = list_length(rules);
-    match n_rules {
-      1 =>
-        let rule = list_lookup(rules, 0);
-        match rule {
-          KRecRule.Mk(ctor_idx, n_fields, rhs) =>
-            let ctor_ci = load(list_lookup(top, ctor_idx));
-            match ctor_ci {
-              KConstantInfo.Ctor(_, _, induct_idx, _, _, _, _) =>
-                let ind_ci = load(list_lookup(top, induct_idx));
-                match ind_ci {
-                  KConstantInfo.Induct(_, _, _, n_indices, ctor_indices, _, _) =>
-                    let n_ctors = list_length(ctor_indices);
-                    match n_ctors {
-                      1 =>
-                        match n_indices {
+  -- Helpers (thin wrappers around Core list ops with concrete type params
+  -- to avoid monomorphization clash under toplevel).
+
+  -- ==========================================================================
+  -- Struct-eta iota (mirror try_struct_eta_iota, Kernel/Whnf.lean:708;
+  -- Rust whnf.rs:1244-1301; Lean toCtorWhenStructure). When a
+  -- single-rule recursor's major premise is stuck but the parent
+  -- inductive is struct-like (1 ctor, 0 indices, non-recursive) and the
+  -- major isn't Prop-typed, the major is definitionally `Ctor major.0
+  -- major.1 ...` (structure eta), so fire the rule with field
+  -- projections in place of ctor args.
+  -- ==========================================================================
+  fn try_struct_eta_iota(rec_ty: KExpr, lvls: List‹KLevel›,
+                               spine: List‹KExpr›, nparams: G, nmotives: G,
+                               nminors: G, nindices: G,
+                               rules: List‹KRecRule›,
+                               types: List‹KExpr›) -> (G, KExpr) {
+    match load(rules) {
+      ListNode.Nil => (0, store(KExprNode.BVar(0))),
+      ListNode.Cons(r, rest) =>
+        match load(rest) {
+          ListNode.Cons(_, _) => (0, store(KExprNode.BVar(0))),
+          ListNode.Nil =>
+            match r {
+              KRecRule.Mk(_, nf, rhs) =>
+                let skip = ((nparams + nmotives) + nminors) + nindices;
+                match se_parent_addr(rec_ty, skip) {
+                  (0, _) => (0, store(KExprNode.BVar(0))),
+                  (_, parent) =>
+                    let ci = load(get_ci(parent));
+                    match ci {
+                      KConstantInfo.Induct(_, _, _, ind_nidx, num_ctors,
+                                             _, _, _) =>
+                        match num_ctors - 1 {
                           0 =>
-                            -- is_rec is computed on demand (the recr flag was
-                            -- dropped from Ixon); memoized per induct_idx.
-                            match computed_is_rec_ind(induct_idx, top) {
+                            match ind_nidx {
                               0 =>
-                                let major = list_lookup(spine, major_idx);
-                                let major_ty = k_infer(major, types, top, addrs);
-                                let prop_p = is_prop_type(major_ty, types, top, addrs);
-                                match prop_p {
+                                match struct_is_rec(parent) {
                                   1 => (0, store(KExprNode.BVar(0))),
-                                  0 =>
-                                    let rhs_inst = expr_inst_levels(rhs, lvls);
-                                    let pmm_end = (num_params + num_motives) + num_minors;
-                                    let pmm = list_take(spine, pmm_end);
-                                    let after_pmm = apply_spine(rhs_inst, pmm);
-                                    let with_projs = apply_n_projs(after_pmm, induct_idx, major, n_fields, 0);
-                                    let post_major = list_drop(spine, major_idx + 1);
-                                    let result = apply_spine(with_projs, post_major);
-                                    (1, result),
+                                  _ =>
+                                    let major = list_lookup(spine, skip);
+                                    let major_ty = k_infer(major, types);
+                                    match is_prop_type(major_ty, types) {
+                                      1 => (0, store(KExprNode.BVar(0))),
+                                      _ =>
+                                        let rhs_inst = expr_inst_levels(rhs, lvls);
+                                        let pmm = list_take(spine,
+                                          (nparams + nmotives) + nminors);
+                                        let after_pmm = apply_spine(rhs_inst, pmm);
+                                        let with_projs = apply_n_projs(
+                                          after_pmm, parent, major, nf, 0);
+                                        let post = list_drop(spine, skip + 1);
+                                        (1, apply_spine(with_projs, post)),
+                                    },
                                 },
                               _ => (0, store(KExprNode.BVar(0))),
                             },
@@ -755,194 +836,304 @@ def whnf := ⟦
                 },
             },
         },
-      _ => (0, store(KExprNode.BVar(0))),
     }
   }
 
-  -- Mirror: Lean kernel Quot.lift / Quot.ind iota.
-  --   Quot.lift α r β f sound (Quot.mk α' r' a) = f a
-  --   Quot.ind α r motive m (Quot.mk α' r' a) = m a
-  --
-  -- spine layout:
-  --   Lift: [α, r, β, f, sound, q] (6 args)
-  --   Ind:  [α, r, motive, m, q]   (5 args)
-  --
-  -- For both: locate q (last arg), whnf it, expect head Const that's
-  -- Quot(_, _, Ctor) (= Quot.mk). Extract `a` (last arg of Quot.mk's
-  -- spine), apply to f or m.
-  fn try_quot_iota(kind: QuotKind, spine: List‹KExpr›, types: List‹KExpr›,
-                   top: List‹&KConstantInfo›, addrs: List‹Addr›) -> (G, KExpr) {
-    match kind {
-      QuotKind.Lift => try_quot_lift(spine, types, top, addrs),
-      QuotKind.Ind => try_quot_ind(spine, types, top, addrs),
-      _ => (0, store(KExprNode.BVar(0))),
+  -- Parse the recursor's parent inductive addr from its type: peel
+  -- (params+motives+minors+indices) foralls, take the major-premise
+  -- forall's dom, return its spine head Const addr.
+  fn se_parent_addr(rec_ty: KExpr, skip: G) -> (G, Addr) {
+    match skip {
+      0 =>
+        match load(rec_ty) {
+          KExprNode.Forall(dom, _) =>
+            match collect_spine(dom) {
+              (h, _) =>
+                match load(h) {
+                  KExprNode.Const(a, _) => (1, a),
+                  _ => (0, store([0u8; 32])),
+                },
+            },
+          _ => (0, store([0u8; 32])),
+        },
+      _ =>
+        match load(rec_ty) {
+          KExprNode.Forall(_, body) => se_parent_addr(body, skip - 1),
+          _ => (0, store([0u8; 32])),
+        },
     }
   }
 
-  fn try_quot_lift(spine: List‹KExpr›, types: List‹KExpr›,
-                   top: List‹&KConstantInfo›, addrs: List‹Addr›) -> (G, KExpr) {
-    let n = list_length(spine);
-    let lt6 = u32_less_than(n, 6);
-    match lt6 {
-      1 => (0, store(KExprNode.BVar(0))),
-      0 =>
-        let f = list_lookup(spine, 3);
-        let q = list_lookup(spine, 5);
-        let a_opt = quot_extract_arg(q, types, top, addrs);
-        match a_opt {
-          (1, a) =>
-            let post = list_drop(spine, 6);
-            let result = apply_spine(store(KExprNode.App(f, a)), post);
-            (1, result),
-          (0, _) => (0, store(KExprNode.BVar(0))),
-        },
+  fn apply_n_projs(head: KExpr, parent: Addr, major: KExpr,
+                        n_fields: G, i: G) -> KExpr {
+    match n_fields - i {
+      0 => head,
+      _ =>
+        let p = store(KExprNode.Proj(parent, i, major));
+        apply_n_projs(store(KExprNode.App(head, p)), parent, major,
+          n_fields, i + 1),
     }
   }
 
-  fn try_quot_ind(spine: List‹KExpr›, types: List‹KExpr›,
-                  top: List‹&KConstantInfo›, addrs: List‹Addr›) -> (G, KExpr) {
-    let n = list_length(spine);
-    let lt5 = u32_less_than(n, 5);
-    match lt5 {
-      1 => (0, store(KExprNode.BVar(0))),
-      0 =>
-        let m = list_lookup(spine, 3);
-        let q = list_lookup(spine, 4);
-        let a_opt = quot_extract_arg(q, types, top, addrs);
-        match a_opt {
-          (1, a) =>
-            let post = list_drop(spine, 5);
-            let result = apply_spine(store(KExprNode.App(m, a)), post);
-            (1, result),
-          (0, _) => (0, store(KExprNode.BVar(0))),
+  -- 1 iff the inductive at `parent` is recursive: any ctor field dom
+  -- mentions a block-member addr (mirror computed_is_rec_ind,
+  -- Inductive.lean:376). Unknown shapes conservatively report 1
+  -- (recursive) so struct-eta refuses. Aiur-memoized per parent.
+  fn struct_is_rec(parent: Addr) -> G {
+    let ci = load(get_ci(parent));
+    match ci {
+      KConstantInfo.Induct(_, _, n_params, _, num_ctors, _, block, idx) =>
+        let members = struct_block_member_addrs(parent, block);
+        struct_scan_ctors(block, idx, num_ctors, n_params, members, 0),
+      _ => 1,
+    }
+  }
+
+  fn struct_block_member_addrs(parent: Addr, block: Addr) -> List‹Addr› {
+    let c = load_verified_constant(block);
+    match c {
+      Constant.Mk(info, _, _, _) =>
+        match info {
+          ConstantInfo.Muts(members) => build_recur_addrs(members, block),
+          _ => store(ListNode.Cons(parent, store(ListNode.Nil))),
         },
     }
   }
 
-  -- WHNF q; if q reduces to `App-spine(Const(Quot.mk), [α, r, a])`,
-  -- return (1, a). Else (0, _).
-  fn quot_extract_arg(q: KExpr, types: List‹KExpr›, top: List‹&KConstantInfo›,
-                      addrs: List‹Addr›) -> (G, KExpr) {
-    let q_whnf = whnf(q, types, top, addrs);
-    let pair = collect_spine(q_whnf);
-    match pair {
-      (head, args) =>
-        match load(head) {
-          KExprNode.Const(idx, _) =>
-            let ci = load(list_lookup(top, idx));
-            match ci {
-              KConstantInfo.Quot(_, _, kind) =>
-                match kind {
-                  QuotKind.Ctor =>
-                    -- Mirror: src/ix/kernel/whnf.rs:2410 Quot.mk has exactly 3 args.
-                    -- Strict equality required: extra spine args are ill-typed
-                    -- and must not silently reduce.
-                    let nargs = list_length(args);
-                    match nargs - 3 {
-                      0 =>
-                        let a = list_lookup(args, 2);
-                        (1, a),
-                      _ => (0, store(KExprNode.BVar(0))),
-                    },
-                  _ => (0, store(KExprNode.BVar(0))),
-                },
-              _ => (0, store(KExprNode.BVar(0))),
+  fn struct_scan_ctors(block: Addr, idx: G, num_ctors: G, n_params: G,
+                             members: List‹Addr›, c: G) -> G {
+    match num_ctors - c {
+      0 => 0,
+      _ =>
+        let cci = load(get_ci_cprj(block, idx, c));
+        match cci {
+          KConstantInfo.Ctor(_, cty, _, _, _, _, _, _) =>
+            let after = se_peel_tol(cty, n_params);
+            match se_scan_fields(after, members) {
+              1 => 1,
+              _ => struct_scan_ctors(block, idx, num_ctors, n_params,
+                     members, c + 1),
             },
-          _ => (0, store(KExprNode.BVar(0))),
+          _ => 1,
         },
     }
   }
 
-  fn apply_n_projs(head: KExpr, induct_idx: G, major: KExpr, n_fields: G, i: G) -> KExpr {
-    match n_fields - i {
-      0 => head,
+  fn se_peel_tol(ty: KExpr, n: G) -> KExpr {
+    match n {
+      0 => ty,
       _ =>
-        let proj_node = store(KExprNode.Proj(induct_idx, i, major));
-        apply_n_projs(store(KExprNode.App(head, proj_node)), induct_idx, major, n_fields, i + 1),
-    }
-  }
-
-  -- Mirror: src/ix/kernel/whnf.rs:1315-1380 synth_ctor_when_k.
-  -- For K-eliminable recursors (1 ctor in Prop, no fields), synthesize
-  -- a nullary ctor application from the spine's params so iota fires.
-  -- Returns (1, ctor_app) on success, (0, _) on miss. Extracts ctor
-  -- universes + params from the major's inferred type (rather than slicing
-  -- recursor's lvls or spine), then verifies the synthesized ctor's type
-  -- is def-eq with major's type.
-  fn try_synth_k_ctor(raw_major: KExpr, num_params: G,
-                      rules: List‹KRecRule›, types: List‹KExpr›,
-                      top: List‹&KConstantInfo›,
-                      addrs: List‹Addr›) -> (G, KExpr) {
-    match load(rules) {
-      ListNode.Nil => (0, store(KExprNode.BVar(0))),
-      ListNode.Cons(rule, _) =>
-        match rule {
-          KRecRule.Mk(ctor_idx, _, _) =>
-            let ctor_ci = load(list_lookup(top, ctor_idx));
-            match ctor_ci {
-              KConstantInfo.Ctor(_, _, induct_idx, _, _, _, _) =>
-                let ind_ci = load(list_lookup(top, induct_idx));
-                match ind_ci {
-                  KConstantInfo.Induct(_, _, _, _, ctor_indices, _, _) =>
-                    let n_ctors = list_length(ctor_indices);
-                    match n_ctors {
-                      0 => (0, store(KExprNode.BVar(0))),
-                      _ =>
-                        let first_ctor = list_lookup(ctor_indices, 0);
-                        let major_ty = k_infer(raw_major, types, top, addrs);
-                        let major_ty_w = whnf(major_ty, types, top, addrs);
-                        match collect_spine(major_ty_w) {
-                          (ty_head, ty_args) =>
-                            match load(ty_head) {
-                              KExprNode.Const(ty_ind_idx, ctor_us) =>
-                                match ty_ind_idx - induct_idx {
-                                  0 =>
-                                    let ctor_head = store(KExprNode.Const(first_ctor, ctor_us));
-                                    let params = list_take(ty_args, num_params);
-                                    let ctor_app = apply_spine(ctor_head, params);
-                                    -- Verify: ctor's inferred type def-eq major's type.
-                                    let ctor_ty = k_infer(ctor_app, types, top, addrs);
-                                    match k_is_def_eq(major_ty_w, ctor_ty, types, top, addrs) {
-                                      1 => (1, ctor_app),
-                                      0 => (0, store(KExprNode.BVar(0))),
-                                    },
-                                  _ => (0, store(KExprNode.BVar(0))),
-                                },
-                              _ => (0, store(KExprNode.BVar(0))),
-                            },
-                        },
-                    },
-                },
+        match load(ty) {
+          KExprNode.Forall(_, body) => se_peel_tol(body, n - 1),
+          _ => ty,
+        },
+    }
+  }
+
+  fn se_scan_fields(ty: KExpr, members: List‹Addr›) -> G {
+    match load(ty) {
+      KExprNode.Forall(dom, body) =>
+        match se_mentions(dom, members) {
+          1 => 1,
+          _ => se_scan_fields(body, members),
+        },
+      _ => 0,
+    }
+  }
+
+  fn se_mentions(e: KExpr, members: List‹Addr›) -> G {
+    match load(e) {
+      KExprNode.Const(a, _) => se_addr_in(a, members),
+      KExprNode.App(f, x) =>
+        match se_mentions(f, members) {
+          1 => 1,
+          _ => se_mentions(x, members),
+        },
+      KExprNode.Lam(t, b) =>
+        match se_mentions(t, members) {
+          1 => 1,
+          _ => se_mentions(b, members),
+        },
+      KExprNode.Forall(t, b) =>
+        match se_mentions(t, members) {
+          1 => 1,
+          _ => se_mentions(b, members),
+        },
+      KExprNode.Let(t, v, b) =>
+        match se_mentions(t, members) {
+          1 => 1,
+          _ =>
+            match se_mentions(v, members) {
+              1 => 1,
+              _ => se_mentions(b, members),
             },
         },
+      KExprNode.Proj(_, _, inner) => se_mentions(inner, members),
+      _ => 0,
     }
   }
 
-  -- ============================================================================
-  -- Helpers
-  -- ============================================================================
-  fn list_lookup_or_nil(list: List‹KExpr›, idx: G) -> KExpr {
-    match load(list) {
-      ListNode.Nil => store(KExprNode.BVar(0)),
-      ListNode.Cons(v, rest) =>
-        match idx {
-          0 => v,
-          _ => list_lookup_or_nil(rest, idx - 1),
+  fn se_addr_in(a: Addr, xs: List‹Addr›) -> G {
+    match load(xs) {
+      ListNode.Nil => 0,
+      ListNode.Cons(x, rest) =>
+        match address_eq(a, x) {
+          1 => 1,
+          _ => se_addr_in(a, rest),
         },
     }
   }
 
-  fn ensure_sort_post_whnf(e: KExpr) -> (G, KLevel) {
+  -- Fast path (mirror whnf): trivial whnf normal forms skip the
+  -- spine machinery and memo row entirely.
+  fn whnf(e: KExpr, types: List‹KExpr›) -> KExpr {
     match load(e) {
-      KExprNode.Srt(l) => (1, l),
-      _ => (0, store(KLevelNode.Zero)),
+      KExprNode.Srt(_) => e,
+      KExprNode.Lit(_) => e,
+      KExprNode.Lam(_, _) => e,
+      KExprNode.Forall(_, _) => e,
+      KExprNode.BVar(_) => e,
+      _ => whnf_core(e, ctx_trim(types, expr_lbr(e))),
     }
   }
 
-  fn ensure_forall_post_whnf(e: KExpr) -> (G, KExpr, KExpr) {
+  fn whnf_core(e: KExpr, types: List‹KExpr›) -> KExpr {
+    whnf_with_spine(e, store(ListNode.Nil), types)
+  }
+
+  -- ============================================================================
+  -- whnf_nd: WHNF without delta-unfolding. Mirror whnf_nd
+  -- crates/kernel/src / Rust whnf.rs::whnf_no_delta.
+  --
+  -- Same dispatch tree as whnf, but the Defn/Thm arms of the const
+  -- head return the stuck application instead of unfolding. Beta / zeta /
+  -- iota / proj / quot / primitives still fire — they don't need delta.
+  --
+  -- Used by def_eq's Tier 1d structural pre-check: many comparisons
+  -- settle at no-delta whnf + ptr_eq or quick structural compare,
+  -- avoiding the cascading full-delta unfold of large Defn bodies.
+  -- ============================================================================
+  fn whnf_nd(e: KExpr, types: List‹KExpr›) -> KExpr {
     match load(e) {
-      KExprNode.Forall(ty, body) => (1, ty, body),
-      _ => (0, store(KExprNode.BVar(0)), store(KExprNode.BVar(0))),
+      KExprNode.Srt(_) => e,
+      KExprNode.Lit(_) => e,
+      KExprNode.Lam(_, _) => e,
+      KExprNode.Forall(_, _) => e,
+      KExprNode.BVar(_) => e,
+      _ => whnf_nd_core(e, ctx_trim(types, expr_lbr(e))),
+    }
+  }
+
+  fn whnf_nd_core(e: KExpr, types: List‹KExpr›) -> KExpr {
+    whnf_nd_with_spine(e, store(ListNode.Nil), types)
+  }
+
+  fn whnf_nd_with_spine(head: KExpr, spine: List‹KExpr›,
+                            types: List‹KExpr›) -> KExpr {
+    match load(head) {
+      KExprNode.App(f, a) =>
+        match collect_spine(head) {
+          (inner_head, inner_spine) =>
+            whnf_nd_with_spine(inner_head, list_concat(inner_spine, spine), types),
+        },
+      KExprNode.Lam(ty, body) =>
+        whnf_nd_apply_beta(spine, head, types),
+      KExprNode.Const(addr, lvls) =>
+        whnf_nd_const_head(addr, lvls, head, spine, types),
+      KExprNode.Let(_, val, body) =>
+        let next = expr_inst1(body, val, 0);
+        whnf_nd_with_spine(next, spine, types),
+      KExprNode.Proj(struct_addr, fidx, inner) =>
+        whnf_nd_proj_head(struct_addr, fidx, inner, spine, types),
+      _ => apply_spine(head, spine),
+    }
+  }
+
+  fn whnf_nd_apply_beta(spine: List‹KExpr›, lam: KExpr,
+                            types: List‹KExpr›) -> KExpr {
+    match peel_beta(lam, spine, store(ListNode.Nil)) {
+      (deep, consumed, rest) =>
+        match list_length(consumed) {
+          0 => apply_spine(lam, spine),
+          1 =>
+            let body2 = expr_inst1(deep, list_lookup(consumed, 0), 0);
+            whnf_nd_with_spine(body2, rest, types),
+          _ =>
+            let body2 = expr_inst_many(deep, consumed, 0);
+            whnf_nd_with_spine(body2, rest, types),
+        },
+    }
+  }
+
+  -- Proj head in no-delta mode: whnf_nd the scrutinee; ctor-field pull
+  -- and the fin_val_decidable_rec push still apply.
+  fn whnf_nd_proj_head(struct_addr: Addr, fidx: G, inner: KExpr,
+                           spine: List‹KExpr›, types: List‹KExpr›) -> KExpr {
+    let inner_whnf = whnf_nd(inner, types);
+    -- Same Str-literal re-expansion as whnf_proj_head.
+    let inner_exp = str_lit_to_ctor_app_or_self(inner_whnf, types);
+    match collect_spine(inner_exp) {
+      (inner_head, inner_args) =>
+        match try_reduce_fin_val_decidable_rec(struct_addr, fidx,
+                inner_head, inner_args) {
+          (1, rewritten) => whnf_nd_with_spine(rewritten, spine, types),
+          _ =>
+            match load(inner_head) {
+              KExprNode.Const(_, _) =>
+                match load(whnf_get_ctor_or_none(inner_head)) {
+                  KConstantInfo.Ctor(_, _, _, _, _, nparams, _, _) =>
+                    let field = list_lookup(inner_args, nparams + fidx);
+                    whnf_nd_with_spine(field, spine, types),
+                  _ =>
+                    let stuck = store(KExprNode.Proj(struct_addr, fidx, inner_whnf));
+                    apply_spine(stuck, spine),
+                },
+              _ =>
+                let stuck = store(KExprNode.Proj(struct_addr, fidx, inner_whnf));
+                apply_spine(stuck, spine),
+            },
+        },
+    }
+  }
+
+  -- Difference from whnf_const_head: Defn/Thm arms return the stuck
+  -- application instead of unfolding. Iota, quot, primitives and the
+  -- projection-definition shortcut still apply (proj-def reads the Defn
+  -- value shape but never expands the body into the term).
+  fn whnf_nd_const_head(addr: Addr, lvls: List‹KLevel›, head: KExpr,
+                            spine: List‹KExpr›, types: List‹KExpr›) -> KExpr {
+    let prim = try_prim_dispatch(addr, lvls, spine, types);
+    match prim {
+      (1, reduced) => whnf_nd(reduced, types),
+      -- verdict 2: already-stuck compact form; do not re-whnf.
+      (2, stuck) => stuck,
+      _ =>
+    let ci = load(get_ci(addr));
+    match ci {
+      KConstantInfo.Defn(_, _, value, _, _) =>
+        let pd = try_reduce_projection_definition(value, spine);
+        match pd {
+          (1, reduced) => whnf_nd(reduced, types),
+          _ => apply_spine(head, spine),
+        },
+      KConstantInfo.Quot(_, _, kind) =>
+        let quot = try_quot_iota(kind, spine, types);
+        match quot {
+          (1, reduced) => whnf_nd(reduced, types),
+          _ => apply_spine(head, spine),
+        },
+      KConstantInfo.Rec(nlvls, rec_ty, nparams, nindices, nmotives, nminors,
+                          rules, k_flag, _unsafe, _block, _ridx) =>
+        let iota = try_iota(lvls, spine, nparams, nmotives, nminors,
+                                 nindices, rules, types, head,
+                                 rec_to_parent_addr(rec_ty, nparams, nmotives,
+                                   nminors, nindices));
+        match iota {
+          (1, reduced) => whnf_nd(reduced, types),
+          _ => apply_spine(head, spine),
+        },
+      _ => apply_spine(head, spine),
+    },
     }
   }
 ⟧
diff --git a/Ix/IxVM/KernelTypes.lean b/Ix/IxVM/KernelTypes.lean
index 7ebc9c593..e51160bb8 100644
--- a/Ix/IxVM/KernelTypes.lean
+++ b/Ix/IxVM/KernelTypes.lean
@@ -7,9 +7,20 @@ namespace IxVM
 
 def kernelTypes := ⟦
   -- ============================================================================
-  -- Universe Levels
+  -- KernelTypes — the addr-first kernel term representation
+  --
+  -- Every constant reference in a KExpr is a content-hash `Addr`, never a
+  -- position. Consumers resolve refs through the memoized `get_ci(addr)`,
+  -- so no global constant list has to be threaded to interpret a term.
+  --
+  -- Precondition: the Lean→Ixon compile alpha-collapses the env before
+  -- witness build, so every logical constant has exactly ONE canonical
+  -- addr and duplicate Muts wrappers are already merged. The kernel does
+  -- no dedup of its own — same content gives the same addr, which the
+  -- store interns to the same pointer, so sharing is automatic.
   -- ============================================================================
 
+  -- Universe Levels.
   enum KLevelNode {
     Zero,
     Succ(KLevel),
@@ -20,13 +31,7 @@ def kernelTypes := ⟦
 
   type KLevel = &KLevelNode
 
-  -- ============================================================================
-  -- Literals
-  -- ============================================================================
-
-  -- Nat bignum: little-endian list of u64 limbs (least-significant first).
-  -- E.g. the number 0x1_00000000_00000001 is [1, 1] (two limbs).
-  -- Zero is represented as List.Nil.
+  -- Literals. Nat literals are little-endian U64 limb lists; see Klimbs.
   type KLimbs = List‹U64›
 
   enum KLiteral {
@@ -35,32 +40,29 @@ def kernelTypes := ⟦
   }
 
   -- ============================================================================
-  -- Expressions (de Bruijn indexed, no binder info or names)
+  -- Expressions — addr-first `Const(Addr, List<KLevel>)`.
+  --
+  -- Proj carries its structure type as an `Addr` too, not an index, so a
+  -- projection is interpretable on its own; consumers resolve it via
+  -- `get_ci(addr)` like any other reference.
   -- ============================================================================
 
   enum KExprNode {
     BVar(G),
     Srt(KLevel),
-    Const(G, List‹KLevel›),
+    Const(Addr, List‹KLevel›),
     App(KExpr, KExpr),
     Lam(KExpr, KExpr),
     Forall(KExpr, KExpr),
     Let(KExpr, KExpr, KExpr),
     Lit(KLiteral),
-    Proj(G, G, KExpr)
+    Proj(Addr, G, KExpr)
   }
 
   type KExpr = &KExprNode
 
-  -- Collect an application spine: peel `App(f, a)` layers, returning the head
-  -- and the args in application order. The single shared definition for every
-  -- kernel caller (whnf, primitive, inductive_check, def_eq) — defined here in
-  -- `kernelTypes` so it precedes them all in the merge.
-  --
-  -- Non-tail (no accumulator): keyed on `e` alone, so Aiur memoization dedups
-  -- shared sub-spines across reductions. An accumulator would thread `acc`
-  -- through the memo key and block that sharing (tail recursion buys nothing in
-  -- Aiur — stack depth is free). `list_snoc` keeps order and is itself memoized.
+  -- collect_spine: peel `App(f, a)` layers. Non-tail, memoized per `e`;
+  -- shared sub-spines dedup.
   fn collect_spine(e: KExpr) -> (KExpr, List‹KExpr›) {
     match load(e) {
       KExprNode.App(f, a) =>
@@ -73,12 +75,9 @@ def kernelTypes := ⟦
   -- ============================================================================
   -- Recursor Rule
   --
-  -- Mirror: src/ix/kernel/constant.rs::RecRule { ctor, fields, rhs }.
-  -- Aiur keeps a global ctor idx in the first slot for direct lookup
-  -- convenience. Could be simplified to (fields, rhs) at the cost of an
-  -- ingress refactor.
-  --
-  -- Layout: (global_ctor_idx, num_fields, rhs).
+  -- the kernel: `cidx` identifies the constructor within the parent inductive.
+  -- Iota matches by `cidx == ctor.cidx`. Rule's ctor address is
+  -- (rec.block_addr, rec.ind_idx, cidx) — implicit from the rec's context.
   -- ============================================================================
 
   enum KRecRule {
@@ -86,31 +85,21 @@ def kernelTypes := ⟦
   }
 
   -- ============================================================================
-  -- Constant Info
+  -- Constant Info — the kernel addr-first
   --
-  -- CIAxiom:  (num_levels, type, is_unsafe)
-  -- CIDefn:   (num_levels, type, value, safety, hints)
+  -- Ctor / Induct / Rec reference their parent Muts wrapper by
+  -- `(block_addr, ind_idx)` pair instead of a synthesized projection
+  -- addr. This avoids needing to compute blake3(IPrj(idx, block_addr))
+  -- at kernel time. Consumers wanting the parent inductive's KCI call
+  -- `get_ci_ind_at(block_addr, ind_idx)`.
   --
-  -- `hints` is a packed G encoding of `Lean.ReducibilityHints`:
-  --   0           = Opaque   (never unfold in whnf; lazy-delta-only)
-  --   1 + h       = Regular(h)  (h up to 2^32 - 2; height drives lazy-delta priority)
-  --   2^32 - 1    = Abbrev   (always unfold, highest priority in lazy-delta)
-  -- Larger value = higher delta-rank (unfold first).
-  -- Plumbed via secondary IOBuffer key `[2] ++ addr` from Lean side.
-  -- CIThm:    (num_levels, type, value)
-  -- CIOpaque: (num_levels, type, value, is_unsafe)
-  -- CIQuot:   (num_levels, type, kind)
-  -- CIInduct: (num_levels, type, num_params, num_indices,
-  --            ctor_indices, is_unsafe)
-  -- The recr/refl/nested flags were dropped from Ixon (derivable from
-  -- constructor structure; trusting declared values was an adversarial
-  -- surface). is_rec is computed on demand via `compute_is_rec`.
-  -- CICtor:   (num_levels, type, induct_idx, cidx,
+  -- CIInduct: (num_levels, type, num_params, num_indices, num_ctors,
+  --            is_unsafe, block_addr, ind_idx)
+  -- CICtor:   (num_levels, type, block_addr, ind_idx, cidx,
   --            num_params, num_fields, is_unsafe)
   -- CIRec:    (num_levels, type, num_params, num_indices,
-  --            num_motives, num_minors, rules, k_flag, is_unsafe, block_addr)
-  -- block_addr = address of the Muts wrapper this Recursor lives in. Used
-  -- by canonical_block_sort to validate recursor-block ordering.
+  --            num_motives, num_minors, rules, k_flag, is_unsafe,
+  --            block_addr, rec_idx)
   -- ============================================================================
 
   enum KConstantInfo {
@@ -119,9 +108,9 @@ def kernelTypes := ⟦
     Thm(G, KExpr, KExpr),
     Opaque(G, KExpr, KExpr, G),
     Quot(G, KExpr, QuotKind),
-    Induct(G, KExpr, G, G, List‹G›, G, Addr),
-    Ctor(G, KExpr, G, G, G, G, G),
-    Rec(G, KExpr, G, G, G, G, List‹KRecRule›, G, G, Addr)
+    Induct(G, KExpr, G, G, G, G, Addr, G),
+    Ctor(G, KExpr, Addr, G, G, G, G, G),
+    Rec(G, KExpr, G, G, G, G, List‹KRecRule›, G, G, Addr, G)
   }
 
 ⟧
diff --git a/Ix/IxVM/Toplevel.lean b/Ix/IxVM/Toplevel.lean
new file mode 100644
index 000000000..bfd5b0702
--- /dev/null
+++ b/Ix/IxVM/Toplevel.lean
@@ -0,0 +1,229 @@
+module
+public import Ix.Aiur.Meta
+public import Ix.IxVM.Core
+public import Ix.IxVM.ByteStream
+public import Ix.IxVM.Blake3
+public import Ix.IxVM.RBTreeMap
+public import Ix.IxVM.Ixon
+public import Ix.IxVM.IxonSerialize
+public import Ix.IxVM.IxonDeserialize
+public import Ix.IxVM.KernelTypes
+public import Ix.IxVM.Kernel.Klimbs
+public import Ix.IxVM.Kernel.NatPrim
+public import Ix.IxVM.Convert
+public import Ix.IxVM.Ingress
+public import Ix.IxVM.Kernel.Levels
+public import Ix.IxVM.Kernel.Subst
+public import Ix.IxVM.Kernel.Whnf
+public import Ix.IxVM.Kernel.InferOnly
+public import Ix.IxVM.Kernel.DefEq
+public import Ix.IxVM.Kernel.Infer
+public import Ix.IxVM.Kernel.CanonicalCheck
+public import Ix.IxVM.Kernel.Check
+public import Ix.IxVM.Kernel.Claim
+
+public section
+
+namespace IxVM
+
+def entrypoints := ⟦
+  -- Check entrypoint. Loads the constant at `addr_bytes` and typechecks
+  -- it via run_check. Refs discovered during the check fault lazily via
+  -- get_ci rather than being walked up front.
+  --
+  -- Checks the constant AT `addr_bytes` and nothing else: its refs are
+  -- ingressed and get_ci'd for their declared types, but are not
+  -- themselves checked. For the transitive discipline use `verify_claim`
+  -- with a Check or CheckEnv claim.
+  pub fn verify_check(addr_bytes: [U8; 32]) {
+    run_check(store(addr_bytes));
+  }
+
+  -- CheckEnv entrypoint. Parses the env tree at `root_bytes` (ch 1),
+  -- checks every leaf via run_check. Faults constants lazily via
+  -- get_ci; shared subterms across leaves ingressed once (memoized).
+  pub fn verify_check_env(root_bytes: [U8; 32]) {
+    run_check_env(store(root_bytes), Option.None);
+  }
+
+  /- # Test entrypoints. These exercise shared infrastructure — the Ixon
+     serde round-trip and the level comparator — rather than the
+     typechecker proper, and are pruned out of the production `ixVM`
+     toplevel below. -/
+
+  pub fn ixon_serde_test(n: G) {
+    match n {
+      0 => (),
+      _ =>
+        let n_minus_1 = n - 1;
+        let (idx, len) = io_get_info(0, [n_minus_1]);
+        let bytes = #read_byte_stream(0, idx, len);
+        let (const, rest) = get_constant(bytes);
+        assert_eq!(load(rest), ListNode.Nil,
+          "ixon deserialization left trailing bytes");
+        let bytes2 = put_constant(const, store(ListNode.Nil));
+        assert_eq!(bytes, bytes2,
+          "ixon round-trip: re-serialized bytes differ from the input");
+        ixon_serde_test(n_minus_1),
+    }
+  }
+
+  fn level_cmp_tests() {
+    let zero = store(KLevelNode.Zero);
+    let p0 = store(KLevelNode.Param(0));
+    let p1 = store(KLevelNode.Param(1));
+    let succ_p0 = store(KLevelNode.Succ(p0));
+    let succ_zero = store(KLevelNode.Succ(zero));
+
+    -- Zero ≤ anything
+    assert_eq!(level_leq(zero, p0), 1, "level_leq: 0 <= u must hold");
+
+    -- Param(u) ≤ Param(u) (reflexivity)
+    assert_eq!(level_leq(p0, p0), 1, "level_leq: u <= u must hold (reflexivity)");
+
+    -- Param(u) ≤ Param(v) fails (u ≠ v, set u > v)
+    assert_eq!(level_leq(p0, p1), 0,
+      "level_leq: distinct params must not compare <=");
+
+    -- Succ(u) ≤ Succ(u) (peel both succs)
+    assert_eq!(level_leq(succ_p0, succ_p0), 1,
+      "level_leq: u+1 <= u+1 must hold (peel both succs)");
+
+    -- Succ(u) ≤ u fails (u+1 > u at any assignment)
+    assert_eq!(level_leq(succ_p0, p0), 0,
+      "level_leq: u+1 <= u must fail at every assignment");
+
+    -- Param(u) ≤ Succ(Param(u)) (u ≤ u+1)
+    assert_eq!(level_leq(p0, succ_p0), 1, "level_leq: u <= u+1 must hold");
+
+    -- max(u, v) ≤ max(u, v) (reflexivity via distribution)
+    let max_uv = store(KLevelNode.Max(p0, p1));
+    assert_eq!(level_leq(max_uv, max_uv), 1,
+      "level_leq: max(u,v) <= max(u,v) must hold (reflexivity via distribution)");
+
+    -- u ≤ max(u, v)
+    assert_eq!(level_leq(p0, max_uv), 1, "level_leq: u <= max(u,v) must hold");
+
+    -- max(u, v) ≤ u fails
+    assert_eq!(level_leq(max_uv, p0), 0, "level_leq: max(u,v) <= u must fail");
+
+    -- imax(u, v) ≤ max(u, v)
+    let imax_uv = store(KLevelNode.IMax(p0, p1));
+    assert_eq!(level_leq(imax_uv, max_uv), 1,
+      "level_leq: imax(u,v) <= max(u,v) must hold");
+
+    -- max(u, v) ≤ imax(u, v) fails
+    assert_eq!(level_leq(max_uv, imax_uv), 0,
+      "level_leq: max(u,v) <= imax(u,v) must fail");
+
+    -- u+1 = max(1, imax(u+1, u)): equal for all σ (case-split fix)
+    let a = succ_p0;
+    let b = store(KLevelNode.Max(
+      succ_zero,
+      store(KLevelNode.IMax(succ_p0, p0))));
+    assert_eq!(level_equal(a, b), 1,
+      "level_equal: u+1 = max(1, imax(u+1, u)) must hold at every assignment");
+
+    -- imax(u, u) = u
+    assert_eq!(level_equal(store(KLevelNode.IMax(p0, p0)), p0), 1,
+      "level_equal: imax(u,u) = u must hold");
+
+    -- max(u, 0) = u
+    assert_eq!(level_equal(store(KLevelNode.Max(p0, zero)), p0), 1,
+      "level_equal: max(u,0) = u must hold");
+
+    -- level_imax reduces imax(u, 1+v) to max(u, 1+v) and imax(u, 0) to 0
+    let succ_v = store(KLevelNode.Succ(p1));
+    assert_eq!(level_eq(
+      level_imax(p0, succ_v),
+      store(KLevelNode.Max(p0, succ_v))), 1,
+      "level_imax must reduce imax(u, 1+v) to max(u, 1+v)");
+
+    assert_eq!(level_eq(
+      level_imax(p0, zero),
+      zero), 1,
+      "level_imax must reduce imax(u, 0) to 0");
+  }
+
+  pub fn kernel_unit_tests() {
+    level_cmp_tests()
+  }
+
+  -- Subject-only typecheck. DEBUG entrypoint, NOT a claim: checks
+  -- `addr_bytes` alone and trusts its transitive deps (they are
+  -- get_ci'd for their declared types but never checked). Used by the
+  -- kernel-arena fixtures, where the
+  -- per-fixture speed matters (shared deps would otherwise be
+  -- revalidated once per fixture) and where a `bad_*` rejection must
+  -- be attributable to the SUBJECT rather than to a dep.
+  --
+  -- Verifier policy must never accept this funcidx as a production
+  -- claim — it carries no claim digest and no assumption discipline.
+  -- Body is deliberately identical to `verify_check`: the two exist as
+  -- separate funcidxs precisely so policy can accept one and reject the
+  -- other.
+  pub fn verify_const(addr_bytes: [U8; 32]) {
+    run_check(store(addr_bytes));
+  }
+
+  -- Claim-discipline entrypoint — the only production entrypoint. Loads
+  -- the claim bytes at ch 0 keyed by `claim_digest`, blake3-binds them
+  -- against that key (so the public input pins which claim was proved),
+  -- then dispatches on the claim variant: Check, CheckEnv, Reveal, and
+  -- Contains. See `run_claim` for the per-variant discipline.
+  pub fn verify_claim(claim_digest: [U8; 32]) {
+    run_claim(claim_digest);
+  }
+⟧
+
+open IxVM (core byteStream blake3 rbTreeMap ixon ixonSerialize ixonDeserialize)
+
+/-- The full IxVM kernel toplevel: shared modules (core, ixon, blake3, …)
+    merged with the kernel-specific `kernelTypes`, `convert`, `ingress`,
+    and `entrypoints`. Carries the test and benchmark entrypoints too;
+    `ixVM` below is the pruned production toplevel. -/
+def ixVMFull : Except Aiur.Global Aiur.Source.Toplevel := do
+  let vm ← core.merge byteStream
+  let vm ← vm.merge blake3
+  let vm ← vm.merge rbTreeMap
+  let vm ← vm.merge ixon
+  let vm ← vm.merge ixonSerialize
+  let vm ← vm.merge ixonDeserialize
+  let vm ← vm.merge kernelTypes
+  let vm ← vm.merge klimbs
+  let vm ← vm.merge natPrim
+  let vm ← vm.merge convert
+  let vm ← vm.merge ingress
+  let vm ← vm.merge levels
+  let vm ← vm.merge subst
+  let vm ← vm.merge whnf
+  let vm ← vm.merge inferOnly
+  let vm ← vm.merge defEq
+  let vm ← vm.merge infer
+  let vm ← vm.merge canonicalCheck
+  let vm ← vm.merge check
+  let vm ← vm.merge claim
+  vm.merge entrypoints
+
+/-- Pruned production toplevel: `verify_claim` and nothing else.
+
+    `verify_const` / `verify_check` / `verify_check_env` are DEBUG
+    entrypoints that trust their dependencies instead of walking them, so
+    a proof made with one attests far less than a claim does. Keeping
+    them here put them in the same verifying key as `verify_claim`,
+    leaving `ix verify`'s funcIdx check as the only thing standing
+    between a debug proof and acceptance — a policy, enforced in one
+    place, with no test asserting it, and no policy at all in the
+    recursive verifier.
+
+    Pruning them makes it structural: under the production VK such a
+    proof cannot exist. Callers that genuinely want a subject-only check
+    build `ixVMFull` and are thereby using a different VK, which is the
+    honest signal. -/
+def ixVM : Except Aiur.Global Aiur.Source.Toplevel := do
+  let vm ← ixVMFull
+  pure (vm.prune [`verify_claim])
+
+end IxVM
+
+end
diff --git a/Ix/Ixon.lean b/Ix/Ixon.lean
index 8288ea4f0..d650ceaf8 100644
--- a/Ix/Ixon.lean
+++ b/Ix/Ixon.lean
@@ -141,8 +141,17 @@ def putU64TrimmedLE (x : UInt64) : PutM Unit := do
   for i in [0:n.toNat] do
     putU8 ((x >>> (i.toUInt64 * 8)).toUInt8)
 
-/-- Read a u64 from minimal little-endian bytes. -/
+/-- Read a u64 from minimal little-endian bytes.
+
+    Widths past 8 are rejected, matching Rust `u64_get_trimmed_le`.
+    Without the guard the shift below wraps — `UInt64.shiftLeft` is taken
+    mod 64 — so byte 8 would OR back into bits 0-7 and a `Tag0` whose
+    payload claims nine bytes would read as a *different value* here than
+    in the kernel, which discards the surplus. Same bytes, same address,
+    two constants. -/
 def getU64TrimmedLE (len : Nat) : GetM UInt64 := do
+  if len > 8 then
+    throw "getU64TrimmedLE: len > 8"
   let mut x : UInt64 := 0
   for i in [0:len] do
     let b ← getU8
diff --git a/Ix/IxonSyntax/AST.lean b/Ix/IxonSyntax/AST.lean
index a3874abc6..41c14e361 100644
--- a/Ix/IxonSyntax/AST.lean
+++ b/Ix/IxonSyntax/AST.lean
@@ -20,13 +20,13 @@ public section
 
 namespace Ixon.Syntax
 
-/-- Grammar version this implementation speaks (R7). The `ixon <n>`
+/-- Grammar version this implementation speaks . The `ixon <n>`
     header is optional: absent means version 1, forever; grammar
     versions ≥ 2 must declare themselves, and canonical version-1
     output omits the header. Mirrors Rust `syntax::VERSION`. -/
 def VERSION : Nat := 1
 
-/-- Parser resource caps (R2: gas for admission). Mirrors Rust
+/-- Parser resource caps . Mirrors Rust
     `syntax::Limits`, including the defaults. -/
 structure Limits where
   /-- Maximum input length in bytes (checked before any work). -/
diff --git a/Ix/IxonSyntax/Parser.lean b/Ix/IxonSyntax/Parser.lean
index d97ab2f40..d0a7c4f9d 100644
--- a/Ix/IxonSyntax/Parser.lean
+++ b/Ix/IxonSyntax/Parser.lean
@@ -140,7 +140,7 @@ def attempt? (p : M α) : M (Option α) := do
     set st
     return none
 
-/-- Depth guard (R2). -/
+/-- Depth guard . -/
 def withDepth (p : M α) : M α := do
   let ctx ← read
   let st ← get
diff --git a/Tests/Ix/IxVM.lean b/Tests/Ix/IxVM.lean
index 8edc12e93..2d9edd246 100644
--- a/Tests/Ix/IxVM.lean
+++ b/Tests/Ix/IxVM.lean
@@ -152,146 +152,113 @@ public def serdeNatAddComm (env : Lean.Environment) : IO AiurTestCase := do
          expectedIOBuffer := ioBuffer
          interpret := false, executionOnly := true }
 
-/-- Build a `verify_claim` invocation for `name` driving the claim
-    `Ix.Claim.check addr none` — fully transitive typecheck of the
-    target's closure. -/
+/-- kernel check with equivalent transitive typecheck semantic.
+    Reshapes an `Ix.Claim.check target none` request as a `CheckEnv`
+    claim whose owned tree lists the target's transitive closure —
+    every member gets typechecked, not just the target. Kernel path:
+    verify_claim → run_check_env → per-leaf run_check.
+
+    Blake3 binding is preserved end-to-end: every closure member
+    reaches the kernel via `get_ci(addr)` which reads bytes from
+    ch 2 and asserts blake3(bytes) == addr before returning. -/
 public def kernelCheck (name : Lean.Name) (env : Lean.Environment) :
     IO AiurTestCase := do
   let ixonEnv ← loadIxonEnv name env
   let target ← lookupAddr ixonEnv name
-  let witness ← IO.ofExcept <| buildClaimWitness ixonEnv (Ix.Claim.check target none)
+  -- Claim.Check with transitive semantics: run_check_transitive walks the
+  -- block-level ref DAG lazily. No AssumptionTree needed — Aiur
+  -- memoization ensures every reachable const/block gets checked exactly
+  -- once, and the FFT cost stays pure typecheck cost with no tree
+  -- hash-verify overhead folded in.
+  let claim := Ix.Claim.check target none
+  let witness ← IO.ofExcept <| buildClaimWitness ixonEnv claim {}
   pure { functionName := witness.funcName, label := s!"Kernel check {name}"
          input := witness.input, inputIOBuffer := witness.inputIOBuffer
          expectedIOBuffer := witness.inputIOBuffer
          interpret := false, executionOnly := true }
 
-/-- Kernel-check targets paired with their expected total FFT cost
-    (rounded to `Nat`). Names listed as strings to dodge name-quotation
-    parser issues with numeric components (e.g. `_private...0...`).
-
-    The pinned cost makes any kernel change that shifts FFT cost cause a
-    test failure, forcing a manual bump here. Failures report the
-    observed cost in the message so it can be pasted back. -/
-private def kernelCheckEntries : List (String × Nat) := [
-  -- Stdlib
-  ("HEq",                                                                1_422_377),
-  ("HEq.rec",                                                            2_248_839),
-  ("Eq.rec",                                                             2_167_118),
-  ("Nat",                                                                1_561_822),
-  ("Nat.add",                                                            11_316_552),
-  ("Nat.add_comm",                                                       47_091_221),
-  ("Nat.decEq",                                                          58_299_184),
-  ("Nat.decLe",                                                          163_010_330),
-  ("Nat.sub_le_of_le_add",                                               434_240_570),
-  -- Offset-stuck regression driver: the succ-step unfold of `x >>> n`
-  -- into a symbolic-base `Nat.div` chain. Exercises the div/mod
-  -- offset-stuck path where rebuilding the stuck form with the wrong
-  -- (add) head corrupted offset-aware def-eq and sent `x >>> k`
-  -- comparisons into full delta-unfolds of the division algorithm.
-  ("Nat.shiftRight_succ",                                                317_421_449),
-  -- Newly-unlocked targets (level_leq Géran normalize).
-  ("Trans.mk",                                                           2_364_054),
-  ("Array.append_assoc",                                                 2_056_848_911),
-  ("Vector.append",                                                      2_117_995_739),
-  -- Primitive reduction theorems (`IxVMPrim`)
-  ("IxVMPrim.nat_add_lit",                                               24_569_820),
-  ("IxVMPrim.nat_sub_lit",                                               29_716_542),
-  ("IxVMPrim.nat_mul_lit",                                               21_633_770),
-  ("IxVMPrim.nat_mul_big",                                               21_121_333),
-  ("IxVMPrim.nat_div_lit",                                               309_509_856),
-  ("IxVMPrim.nat_mod_lit",                                               316_710_104),
-  ("IxVMPrim.nat_succ_lit",                                              6_388_951),
-  ("IxVMPrim.nat_pred_lit",                                              12_937_436),
-  ("IxVMPrim.nat_gcd_lit",                                               512_049_961),
-  ("IxVMPrim.nat_land_lit",                                              863_876_396),
-  ("IxVMPrim.nat_lor_lit",                                               864_538_928),
-  ("IxVMPrim.nat_xor_lit",                                               871_819_843),
-  ("IxVMPrim.nat_shl_lit",                                               30_606_446),
-  ("IxVMPrim.nat_shr_lit",                                               313_936_489),
-  ("IxVMPrim.nat_pow_big",                                                63_371_031),
-  ("IxVMPrim.nat_beq_lit",                                               21_216_717),
-  ("IxVMPrim.nat_ble_lit",                                               19_681_496),
-  ("IxVMPrim.nat_cases_big",                                             12_574_731),
-  ("IxVMPrim.nat_dec_le",                                                168_723_623),
-  ("IxVMPrim.nat_dec_lt",                                                172_272_111),
-  ("IxVMPrim.nat_dec_eq",                                                70_281_013),
-  ("IxVMPrim.str_size_lit",                                              615_742_529),
-  ("IxVMPrim.bv_to_nat_lit",                                             489_428_838),
-  -- Mutual block + multi-member recursors
-  ("IxVMInd.Even",                                                       22_796_180),
-  ("IxVMInd.Odd",                                                        22_559_147),
-  ("IxVMInd.Even.rec",                                                   27_740_095),
-  ("IxVMInd.Odd.rec",                                                    27_737_306),
-  -- Nested inductive + aux recursor (Tree.mk : List Tree → Tree)
-  ("IxVMInd.Tree",                                                       2_253_665),
-  ("IxVMInd.Tree.rec",                                                   4_184_733),
-  -- Aux dedup: distinct spec_params on one external inductive (3 motives).
-  ("IxVMInd.DedupM",                                                     4_231_601),
-  ("IxVMInd.DedupM.rec",                                                 6_964_804),
-  -- Aux dedup de-lift guard: equal spec_params at field depths 0 and 2.
-  ("IxVMInd.DepthM",                                                     3_135_027),
-  ("IxVMInd.DepthM.rec",                                                 5_460_512),
-  -- Edge cases from prelude
-  ("String.Internal.append",                                             608_754_163),
-  ("_private.Init.Prelude.0.Lean.extractMainModule._unsafe_rec",         914_698_909),
-  -- Aux recursor with transitively-nested inductives (Syntax → Array Syntax
-  -- → List Syntax); shard 53 regression driver.
-  ("Lean.Syntax.rec",                                                    631_819_629),
-  -- Canonical aux order with structurally-distinct exts that tie weak
-  -- through sentinels: the trailing identity marker must decide by
-  -- external address, matching compile order (the Lean.Json.rec bug;
-  -- Json itself is ~68G FFT, far too heavy to pin here). AuxTie is
-  -- verified to fail on the pre-marker kernel.
-  ("IxVMInd.AuxTie",                                                     68_499_165),
-  ("IxVMInd.AuxTie.rec",                                                 77_049_263),
-  -- Parameterized Prop class whose ctor field references the params
-  -- under local ∀-binders: is_rec_field's classification whnf must not
-  -- build a context from the peeled binder doms (frame-level param refs
-  -- give those doms loose ranges exceeding the local depth, running the
-  -- ctx-trim cut walk off the end of the list).
-  ("String.Slice.Pattern.Model.NoPrefixForwardPatternModel.rec",         850_286_686),
-  -- Universe-polymorphic nested inductive: aux occurrence universes must
-  -- carry the univ_offset-shifted frame into minor construction.
-  ("Lean.Widget.TaggedText.rec",                                         613_779_550),
-  -- Aux-member recursors: the canonical param walk peels the PRIMARY
-  -- inductive's type, not self's.
-  ("Lean.Doc.Part.rec",                                                  639_391_067),
-  -- Multi-aux mutual block whose canonical aux order hinges on comparing
-  -- stored (Succ-distributed-into-Max) levels structurally: level_max
-  -- must not factor Succ back out of Max.
-  ("Lean.Doc.Block.rec",                                                 670_857_859),
-  -- Evaporated-aux canonicalization (Tests/Ix/Compile/Mutual.lean AuxDedup*):
-  -- SCC splitting strands `rec_N` auxes whose spec-param inductives moved to
-  -- other SCCs; their claims alias the external inductive's recursor
-  -- (`List.rec`) — hence the identical pin on all four evaporated entries,
-  -- whose claims are literally the same `List.rec` closure. AuxDedupMixed
-  -- mixes one genuine canonical aux (`M.rec_1`, over `List M`) with one
-  -- evaporated alias (`M.rec_2`, over `List B`).
-  ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A",             3_084_348),
-  ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A.rec",         3_873_841),
-  ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A.rec_1",       2_627_832),
-  ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A.rec_2",       2_627_832),
-  ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup2.A.rec_1",       2_627_832),
-  ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M",         3_115_727),
-  ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M.rec",     5_379_916),
-  ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M.rec_1",   5_381_872),
-  ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M.rec_2",   2_627_832),
-  -- Structural string fold (StringReduction strOfListFoldSize*):
-  -- `utf8ByteSize` over a `String.ofList [chars]` application. The unary
-  -- native rule misses (argument is not a literal), so the check
-  -- normalizes the constructor build through the byte model — per
-  -- character through `Char.ofNat` validity and `List.utf8Encode`. Pins
-  -- the in-circuit cost of that fold.
-  ("strOfListFoldSize",                                                  736_138_090),
-  ("strOfListFoldSizeAscii",                                             720_671_439),
-]
-
 private def nameOfString (str : String) : Lean.Name :=
   str.splitOn "." |>.foldl (init := .anonymous) fun acc s =>
     match s.toNat? with
     | some n => .mkNum acc n
     | none   => .mkStr acc s
 
+/-- Exact FFT-cost pins, one per checked constant. These are equality
+    assertions, not budgets: any kernel change that shifts the cost of a
+    listed constant fails the suite, so a regression cannot land quietly
+    and an improvement has to be acknowledged by re-pinning. -/
+private def kernelCheckEntries : List (String × Nat) := [
+  ("HEq",                                                                 395_929),
+  ("HEq.rec",                                                             1_323_957),
+  ("Eq.rec",                                                              1_249_732),
+  ("Nat",                                                                 397_937),
+  ("Nat.add",                                                             9_793_752),
+  ("Nat.add_comm",                                                        42_986_025),
+  ("Nat.decEq",                                                           54_205_687),
+  ("Nat.decLe",                                                           150_997_192),
+  ("Nat.sub_le_of_le_add",                                                411_446_712),
+  ("Nat.shiftRight_succ",                                                 298_900_522),
+  ("Trans.mk",                                                            1_642_739),
+  ("Array.append_assoc",                                                  1_955_894_496),
+  ("Vector.append",                                                       2_010_843_274),
+  ("IxVMPrim.nat_add_lit",                                                21_323_286),
+  ("IxVMPrim.nat_sub_lit",                                                26_044_707),
+  ("IxVMPrim.nat_mul_lit",                                                19_133_523),
+  ("IxVMPrim.nat_mul_big",                                                18_646_232),
+  ("IxVMPrim.nat_div_lit",                                                291_454_780),
+  ("IxVMPrim.nat_mod_lit",                                                298_094_864),
+  ("IxVMPrim.nat_succ_lit",                                               4_819_629),
+  ("IxVMPrim.nat_pred_lit",                                               10_886_578),
+  ("IxVMPrim.nat_gcd_lit",                                                484_388_357),
+  ("IxVMPrim.nat_land_lit",                                               818_645_514),
+  ("IxVMPrim.nat_lor_lit",                                                819_326_288),
+  ("IxVMPrim.nat_xor_lit",                                                825_128_771),
+  ("IxVMPrim.nat_shl_lit",                                                27_004_127),
+  ("IxVMPrim.nat_shr_lit",                                                295_512_764),
+  ("IxVMPrim.nat_pow_big",                                                58_091_666),
+  ("IxVMPrim.nat_beq_lit",                                                18_367_826),
+  ("IxVMPrim.nat_ble_lit",                                                16_978_336),
+  ("IxVMPrim.nat_cases_big",                                              10_615_204),
+  ("IxVMPrim.nat_dec_le",                                                 155_960_877),
+  ("IxVMPrim.nat_dec_lt",                                                 159_088_116),
+  ("IxVMPrim.nat_dec_eq",                                                 64_802_557),
+  ("IxVMPrim.str_size_lit",                                               568_234_929),
+  ("IxVMPrim.bv_to_nat_lit",                                              459_893_577),
+  ("IxVMInd.Even",                                                        19_936_940),
+  ("IxVMInd.Odd",                                                         19_937_288),
+  ("IxVMInd.Even.rec",                                                    24_506_094),
+  ("IxVMInd.Odd.rec",                                                     24_506_759),
+  ("IxVMInd.Tree",                                                        797_366),
+  ("IxVMInd.Tree.rec",                                                    3_329_560),
+  ("IxVMInd.DedupM",                                                      1_892_177),
+  ("IxVMInd.DedupM.rec",                                                  5_213_636),
+  ("IxVMInd.DepthM",                                                      1_348_176),
+  ("IxVMInd.DepthM.rec",                                                  4_121_105),
+  ("String.Internal.append",                                              560_672_572),
+  ("_private.Init.Prelude.0.Lean.extractMainModule._unsafe_rec",          844_799_366),
+  ("Lean.Syntax.rec",                                                     575_453_296),
+  ("IxVMInd.AuxTie",                                                      53_246_147),
+  ("IxVMInd.AuxTie.rec",                                                  63_577_158),
+  ("String.Slice.Pattern.Model.NoPrefixForwardPatternModel.rec",          789_279_052),
+  ("Lean.Widget.TaggedText.rec",                                          566_116_263),
+  ("Lean.Doc.Part.rec",                                                   577_118_615),
+  ("Lean.Doc.Block.rec",                                                  615_022_749),
+  ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A", 1_289_118),
+  ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A.rec", 2_156_728),
+  ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A.rec_1", 1_714_116),
+  ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A.rec_2", 1_714_116),
+  ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup2.A.rec_1", 1_714_116),
+  ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M", 1_325_732),
+  ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M.rec", 4_190_716),
+  ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M.rec_1", 4_190_615),
+  ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M.rec_2", 1_714_116),
+  ("strOfListFoldSize",                                                   643_915_593),
+  ("strOfListFoldSizeAscii",                                              644_205_521),
+]
+
+/-- Variant of `kernelChecks`, pinned to the baseline
+    (`kernelCheckEntries`). Any kernel change that shifts the kernel FFT
+    cost fails the suite and forces a manual pin bump. -/
 public def kernelChecks (env : Lean.Environment) : IO (List AiurTestCase) :=
   kernelCheckEntries.mapM fun (name, expected) => do
     let tc ← kernelCheck (nameOfString name) env
@@ -321,13 +288,11 @@ public def runParityCase (compiled : Aiur.CompiledToplevel)
           (bQC.zip cQC).all fun (b, c) =>
             b.uniqueRows == c.uniqueRows && b.totalHits == c.totalHits)
 
-/-- Parity fixtures: every pinned `kernelCheckEntries` constant runs a
-    realistic workload (blake3, ingress, whnf, def-eq, recursor gen)
-    against the same IOBuffer under both engines. Parity requires
-    entrypoints present in the codegen'd kernel, i.e. the PRUNED
-    production toplevel — test-only entries (`kernel_unit_tests`) are
-    interpreter-only and covered by the `ixvm` suite's full-toplevel
-    exec cases instead. -/
+/-- Codegen parity fixtures: run each check through both the Aiur
+    bytecode interpreter and the generated Rust kernel, and assert they
+    agree on output, IOBuffer, and QueryCount. This is the gate that keeps
+    `crates/ixvm-codegen` in step with the Lean kernel source — an Aiur
+    edit without a `ix codegen` regen fails here. -/
 public def parityCases (env : Lean.Environment) : IO (List AiurTestCase) := do
   kernelCheckEntries.mapM fun (name, _) =>
     kernelCheck (nameOfString name) env
@@ -362,8 +327,10 @@ private def singletonTrees (tree : Ix.AssumptionTree) :
     Std.HashMap Address Ix.AssumptionTree :=
   ({} : Std.HashMap _ _).insert tree.root tree
 
-/-- `Check` claim with `assumptions = some tree.root` covering every
-    transitive dep — kernel ends up checking only the subject. -/
+/-- the kernel `Check` with `assumptions = some tree.root` covering every
+    transitive dep — the cutoff walk (strict=0) stops at each frontier
+    member, so the kernel ends up checking only the subject. the kernel analog
+    of `claimCheckWithAsm`. -/
 public def claimCheckWithAsm (ixonEnv : Ixon.Env) : IO AiurTestCase := do
   let target ← lookupAddr ixonEnv ``Nat.zero
   let closure := closureFrom ixonEnv target
@@ -376,27 +343,37 @@ public def claimCheckWithAsm (ixonEnv : Ixon.Env) : IO AiurTestCase := do
     (Ix.Claim.check target (some tree.root)) (singletonTrees tree)
   pure (asTestCase "Claim Check with-asm (Nat.zero)" witness)
 
-/-- `Contains` claim against a synthetic 3-leaf merkle tree. -/
-public def claimContains : IO AiurTestCase := do
-  let a : Address := ⟨⟨Array.replicate 32 0x11⟩⟩
-  let b : Address := ⟨⟨Array.replicate 32 0x22⟩⟩
-  let c : Address := ⟨⟨Array.replicate 32 0x33⟩⟩
-  let some tree := Ix.AssumptionTree.canonical #[a, b, c]
-    | throw <| IO.userError "Contains tree build failed"
-  let witness ← IO.ofExcept <| buildClaimWitness ({} : Ixon.Env)
-    (Ix.Claim.contains tree.root b) (singletonTrees tree)
-  pure (asTestCase "Claim Contains (synthetic 3-leaf)" witness)
-
-/-- `CheckEnv` claim over the shared smoke env. -/
-public def claimCheckEnv (ixonEnv : Ixon.Env) : IO AiurTestCase := do
+/-- the kernel CheckEnv, self-contained: owned tree = every env constant.
+    Exercises the R1 strict owned-membership rule over a closure that
+    covers itself (walk-reachable ⊆ owned, empty asm). -/
+public def claimCheckEnvFull (ixonEnv : Ixon.Env) : IO AiurTestCase := do
   let some tree := envCanonicalTree ixonEnv
     | throw <| IO.userError "envCanonicalTree empty"
   let witness ← IO.ofExcept <| buildClaimWitness ixonEnv
     (Ix.Claim.checkEnv tree.root none) (singletonTrees tree)
-  pure (asTestCase "Claim CheckEnv (shared smoke env)" witness)
+  pure (asTestCase "CheckEnv self-contained (shared smoke env)" witness)
+
+/-- the kernel CheckEnv with a thin frontier asm: owned = {Nat.add_comm},
+    asm = the direct block-level refs of its constant. Exercises the
+    R1 asm-cutoff walk: the single owned leaf is checked, the walk
+    stops at every frontier member (no recursion below), and strict
+    membership passes because the leaf is owned. Bytes for the full
+    closure stay in ch 2 — delta unfolding punches through the
+    frontier, only the CHECK scope stops there. -/
+public def claimCheckEnvFrontier (ixonEnv : Ixon.Env) : IO AiurTestCase := do
+  let target ← lookupAddr ixonEnv ``Nat.add_comm
+  let some c := ixonEnv.getConst? target
+    | throw <| IO.userError "Nat.add_comm constant missing"
+  let some ownedTree := Ix.AssumptionTree.canonical #[target]
+    | throw <| IO.userError "owned tree build failed"
+  let some asmTree := Ix.AssumptionTree.canonical c.refs
+    | throw <| IO.userError "asm (frontier) tree build failed"
+  let trees := (singletonTrees ownedTree).insert asmTree.root asmTree
+  let witness ← IO.ofExcept <| buildClaimWitness ixonEnv
+    (Ix.Claim.checkEnv ownedTree.root (some asmTree.root)) trees
+  pure (asTestCase "CheckEnv frontier-asm (Nat.add_comm)" witness)
 
-/-- `Reveal` Defn with `kind` + `safety` only — exercises the
-    enum-tag compare path with no Expr hashing. -/
+/-- the kernel `Reveal` Defn (kind+safety) — coverage. -/
 public def claimRevealDefnFields (ixonEnv : Ixon.Env) : IO AiurTestCase := do
   let (comm, info) ← findConstWithOrThrow ixonEnv "Defn"
     fun ci => match ci with | .defn _ => true | _ => false
@@ -404,22 +381,12 @@ public def claimRevealDefnFields (ixonEnv : Ixon.Env) : IO AiurTestCase := do
     | throw <| IO.userError "findConstWith returned non-Defn"
   let revealInfo : Ix.RevealConstantInfo :=
     .defn (some d.kind) (some d.safety) none none none
-  let witness ← IO.ofExcept <| buildClaimWitness ixonEnv (Ix.Claim.reveal comm revealInfo)
+  let witness ← IO.ofExcept <| buildClaimWitness ixonEnv
+    (Ix.Claim.reveal comm revealInfo) {}
   pure (asTestCase "Claim Reveal Defn (kind+safety)" witness)
 
-/-- `Reveal` CPrj — projection idx, cidx, block fields. -/
-public def claimRevealCPrj (ixonEnv : Ixon.Env) : IO AiurTestCase := do
-  let (comm, info) ← findConstWithOrThrow ixonEnv "CPrj"
-    fun ci => match ci with | .cPrj _ => true | _ => false
-  let .cPrj p := info
-    | throw <| IO.userError "findConstWith returned non-CPrj"
-  let revealInfo : Ix.RevealConstantInfo :=
-    .cPrj (some p.idx) (some p.cidx) (some p.block)
-  let witness ← IO.ofExcept <| buildClaimWitness ixonEnv (Ix.Claim.reveal comm revealInfo)
-  pure (asTestCase "Claim Reveal CPrj (all fields)" witness)
-
-/-- `Reveal` Defn `typ` via content-hash binding — exercises the
-    Aiur `expr_addr` path against `blake3(putExpr d.typ)` on Lean. -/
+/-- the kernel `Reveal` Defn `typ` via content-hash binding — exercises the
+    the kernel `expr_addr` path. -/
 public def claimRevealDefnExpr (ixonEnv : Ixon.Env) : IO AiurTestCase := do
   let (comm, info) ← findConstWithOrThrow ixonEnv "Defn"
     fun ci => match ci with | .defn _ => true | _ => false
@@ -428,37 +395,98 @@ public def claimRevealDefnExpr (ixonEnv : Ixon.Env) : IO AiurTestCase := do
   let typAddr := Address.blake3 (Ixon.runPut (Ixon.putExpr d.typ))
   let revealInfo : Ix.RevealConstantInfo :=
     .defn none none none (some typAddr) none
-  let witness ← IO.ofExcept <| buildClaimWitness ixonEnv (Ix.Claim.reveal comm revealInfo)
+  let witness ← IO.ofExcept <| buildClaimWitness ixonEnv
+    (Ix.Claim.reveal comm revealInfo) {}
   pure (asTestCase "Claim Reveal Defn (typ Expr addr)" witness)
 
-/-- `Reveal` Muts — first component, one variant-appropriate
-    field set. -/
-public def claimRevealMuts (ixonEnv : Ixon.Env) : IO AiurTestCase := do
-  let (comm, info) ← findConstWithOrThrow ixonEnv "Muts"
-    fun ci => match ci with | .muts _ => true | _ => false
-  let .muts components := info
-    | throw <| IO.userError "findConstWith returned non-Muts"
-  let some firstMc := components[0]?
-    | throw <| IO.userError "Muts components empty"
-  let revealMc : Ix.RevealMutConstInfo := match firstMc with
-    | .defn d => .defn (some d.kind) (some d.safety) none none none
-    | .indc i => .indc (some i.isUnsafe) none none none none none
-    | .recr r => .recr (some r.k) (some r.isUnsafe) none none none none none
-                       none none
-  let revealInfo : Ix.RevealConstantInfo := .muts #[(0, revealMc)]
-  let witness ← IO.ofExcept <| buildClaimWitness ixonEnv (Ix.Claim.reveal comm revealInfo)
-  pure (asTestCase "Claim Reveal Muts (first component)" witness)
-
-/-- All claim-variant smoke tests packaged for the `ixvm` runner.
-    Builds the shared Ixon env once and threads it through every
-    test. -/
-public def claimSmokeTests (env : Lean.Environment) : IO (List AiurTestCase) := do
-  let ixonEnv ← loadSharedIxonEnv #[``Nat.zero, ``Nat.add_comm] env
-  let t1 ← claimCheckWithAsm ixonEnv
-  let t2 ← claimContains
-  let t3 ← claimCheckEnv ixonEnv
-  let t4 ← claimRevealDefnFields ixonEnv
-  let t5 ← claimRevealCPrj ixonEnv
-  let t6 ← claimRevealDefnExpr ixonEnv
-  let t7 ← claimRevealMuts ixonEnv
-  pure [t1, t2, t3, t4, t5, t6, t7]
+/-- the kernel `Reveal` CPrj — all projection fields. coverage. -/
+public def claimRevealCPrj (ixonEnv : Ixon.Env) : IO AiurTestCase := do
+  let (comm, info) ← findConstWithOrThrow ixonEnv "CPrj"
+    fun ci => match ci with | .cPrj _ => true | _ => false
+  let .cPrj p := info
+    | throw <| IO.userError "findConstWith returned non-CPrj"
+  let revealInfo : Ix.RevealConstantInfo :=
+    .cPrj (some p.idx) (some p.cidx) (some p.block)
+  let witness ← IO.ofExcept <| buildClaimWitness ixonEnv
+    (Ix.Claim.reveal comm revealInfo) {}
+  pure (asTestCase "Claim Reveal CPrj (all fields)" witness)
+
+/-- the kernel `Contains` against a synthetic 3-leaf tree. -/
+public def claimContains : IO AiurTestCase := do
+  let a : Address := ⟨⟨Array.replicate 32 0x11⟩⟩
+  let b : Address := ⟨⟨Array.replicate 32 0x22⟩⟩
+  let c : Address := ⟨⟨Array.replicate 32 0x33⟩⟩
+  let some tree := Ix.AssumptionTree.canonical #[a, b, c]
+    | throw <| IO.userError "Contains tree build failed"
+  let witness ← IO.ofExcept <| buildClaimWitness ({} : Ixon.Env)
+    (Ix.Claim.contains tree.root b) (singletonTrees tree)
+  pure (asTestCase "Claim Contains (synthetic 3-leaf)" witness)
+
+
+/-! ## Shard pipeline
+
+The one path where the WITNESS is built in Rust rather than Lean:
+`shardCheckWithEnv` hands an `EnvHandle` plus an owned-address blob to
+`build_shard_check_env_witness`, which walks the closure, converts
+bytes, and commits the thin-frontier asm tree in parallel Rust. Every
+other suite case builds its witness Lean-side, so without this the
+Rust builder — including the thin-frontier convention that determines
+CheckEnv claim digests — would be untested. -/
+
+/-- Group key for shard partitioning: projection wrappers group with
+    their block, everything else is its own group. Keeps a block and
+    all its wrappers in one shard, so an owned set is walk-closed at
+    both block and wrapper granularity. -/
+private def shardGroupOf (a : Address) (ci : Ixon.ConstantInfo) : Address :=
+  match ci with
+  | .iPrj p | .cPrj p | .rPrj p | .dPrj p => p.block
+  | _ => a
+
+/-- Root namespace component of an Ixon name (`String.utf8ByteSize` →
+    `"String"`). -/
+private partial def ixNameRoot : Ix.Name → Option String
+  | .str (.anonymous _) s _ => some s
+  | .str p _ _ => ixNameRoot p
+  | .num p _ _ => ixNameRoot p
+  | .anonymous _ => none
+
+/-- Synthetic shard over the utf8-decode theorem's closure: owned = the
+    `String`/`Char` subsystem's block groups, frontier = its direct
+    out-of-owned refs. Non-toy on all three axes (owned in the dozens,
+    closure in the thousands, frontier in the hundreds) while staying
+    inside a few B FFT.
+
+    Runs through the Rust witness builder + native kernel via
+    `shardCheckWithEnv`. Execution-only: the pinned FFT cost is the
+    regression signal. -/
+public def shardCheckEnvCase (env : Lean.Environment) :
+    IO (Option (Aiur.EnvHandle × ByteArray)) := do
+  let base : Lean.Name :=
+    .str (.str .anonymous "ByteArray") "utf8DecodeChar?_utf8EncodeChar_append"
+  if !env.constants.contains base then return none
+  let ixonEnv ← loadIxonEnv base env
+  let mut groups : Std.HashMap Address (Array Address) := {}
+  let mut ownedGroups : Std.HashSet Address := {}
+  for (a, lc) in ixonEnv.consts do
+    if let some c := lc.get? then
+      let k := shardGroupOf a c.info
+      groups := groups.insert k ((groups.getD k #[]).push a)
+      if let some n := ixonEnv.addrToName[a]? then
+        if ixNameRoot n == some "String" || ixNameRoot n == some "Char" then
+          ownedGroups := ownedGroups.insert k
+  let mut owned : Array Address := #[]
+  for k in ownedGroups.toArray do owned := owned ++ groups.getD k #[]
+  -- Distinct from the `none` above, which means the target constant is
+  -- absent from this toolchain. Reaching here means the target EXISTS but
+  -- the shard partitioning selected nothing to own, i.e. the fixture
+  -- stopped exercising the Rust witness builder and thin-frontier claim
+  -- convention. Reporting that as a skip would leave the only test of
+  -- that path permanently green while testing nothing.
+  if owned.isEmpty then
+    throw <| IO.userError "shardCheckEnvCase: target present but the \
+      partition selected zero owned constants — fixture no longer \
+      exercises the shard pipeline"
+  let envBytes ← IO.ofExcept (Ixon.serEnv ixonEnv)
+  let handle ← IO.ofExcept (Aiur.EnvHandle.fromBytes envBytes)
+  let ownedBlob : ByteArray := owned.foldl (fun b a => b ++ a.hash) .empty
+  return some (handle, ownedBlob)
diff --git a/Tests/Ix/IxVM/Exploits.lean b/Tests/Ix/IxVM/Exploits.lean
new file mode 100644
index 000000000..cb43a9fb5
--- /dev/null
+++ b/Tests/Ix/IxVM/Exploits.lean
@@ -0,0 +1,706 @@
+/-
+  Adversarial Ixon fixtures: exploit attempts authored DIRECTLY as
+  `Ixon.Constant` values, bypassing the Lean → Ixon compiler.
+
+  The kernel-arena corpus (`Tests.Ix.Kernel.Arena`) attacks the layer
+  ABOVE this one: its `bad_*` fixtures are raw `Lean.ConstantInfo`
+  declarations that skip Lean's elaborator, but they are still compiled
+  by `rsCompileEnvFFI`, so the Ixon they produce is always well-formed —
+  `sharing` comes from real sharing analysis, `refs` from the `IndexSet`
+  of addresses actually referenced. An honest compiler cannot emit the
+  malformed Ixon a real prover is free to author.
+
+  This suite closes that gap. A prover controls the constant bytes and
+  the IOBuffer; content-addressing binds bytes to an address, but NOT
+  the shape of those bytes to anything the compiler would have produced.
+  So every structural premise the kernel relies on but does not assert
+  is reachable from here.
+
+  ## Threat model
+
+  This is a zkDSL: resource exhaustion and aborts are NOT threats (a
+  dishonest prover only pays its own trace). The only threat is a WRONG
+  ANSWER — the kernel ACCEPTING a claim that is false. So an exploit case
+  asserts REJECTION, and a case that flips to accepting is a soundness
+  hole (or a fixture that stopped reaching its target).
+
+  A case may instead assert ACCEPTANCE when accepting is the specified
+  semantics and the claim is merely VACUOUS rather than false — a
+  conditional claim that assumes its own target being the example. Those
+  mark where the kernel's obligation ends and a consumer's begins; they
+  are pinned so the boundary cannot move silently.
+
+  ## Writing a case
+
+  Each `ExploitCase` carries the intent it would buy an attacker, so a
+  failure reads as a security statement rather than a broken test. Pair
+  every exploit with CONTROLS that differ minimally from it: one showing
+  the smuggled-past constant really is ill-typed, one showing the kernel
+  catches it absent the exploit trick. Without those a green suite may
+  only mean the fixture never reached the code it targets.
+-/
+import Ix.Ixon
+import Ix.Claim
+import Ix.IxVM
+import Ix.IxVM.ClaimHarness
+import Ix.Aiur.Protocol
+import Ix.Aiur.Compiler
+import Tests.Aiur.Common
+import LSpec
+
+open LSpec
+
+namespace Tests.Ix.IxVM.Exploits
+
+/-- An attempted exploit, or a control that anchors one.
+
+    `expectAccept := false` (the default) means the kernel MUST reject:
+    execution has to fail, and it should fail via an in-kernel
+    `assert_eq!` rather than by accident. -/
+structure ExploitCase where
+  /-- Short kebab-case identifier, used in the test label. -/
+  name : String
+  /-- The false statement the kernel would endorse by accepting. Read
+      this first when the case fails. -/
+  intent : String
+  /-- The adversarial env: hand-built constants, stored at their own
+      content addresses. -/
+  env : Ixon.Env
+  /-- The claim submitted against `env`. -/
+  claim : Ix.Claim
+  /-- Assumption trees the claim's roots refer to, if any. -/
+  trees : Std.HashMap Address Ix.AssumptionTree := {}
+  /-- Whether the kernel is expected to ACCEPT. Exploits set `false`;
+      controls that must typecheck set `true`. -/
+  expectAccept : Bool := false
+
+/-! ## Ixon construction helpers
+
+The compiler is deliberately not involved: these build the bytes a
+prover would. `constAddr` is the same content-addressing the kernel
+enforces (`load_verified_constant` asserts `blake3(bytes) == addr`), so
+a fixture cannot accidentally desync its address from its content. -/
+
+/-- Content address of a hand-built constant: `blake3` over its Ixon
+    serialization, matching the kernel's `verify_bytes_against`. -/
+def constAddr (c : Ixon.Constant) : Address :=
+  Address.blake3 (Ixon.ser c)
+
+/-- Store `c` at its own content address; returns the updated env and
+    that address.
+
+    A `Defn` also gets a reducibility hint registered: `get_ci` faults
+    one from channel 3 for every definition it resolves, so a hand-built
+    env without it aborts with `invalid IO key` long before the checker
+    runs. `.opaque` keeps delta-unfolding out of the picture, which is
+    what a structural fixture wants. -/
+def storeAt (env : Ixon.Env) (c : Ixon.Constant) : Ixon.Env × Address :=
+  let addr := constAddr c
+  let env := env.storeConst addr c
+  -- A `DPrj` resolves to its block's definition member and faults the
+  -- hint under the WRAPPER's address (`get_ci_dprj`), so wrappers need
+  -- one just as standalone definitions do.
+  let env := match c.info with
+    | .defn _ | .dPrj _ =>
+      { env with anonHints := env.anonHints.insert addr .opaque }
+    | _ => env
+  (env, addr)
+
+/-- A `Definition`-flavoured constant with explicit tables. `sharing` is
+    a parameter because it is exactly what the compiler would never let
+    an attacker choose. -/
+def defnConst (kind : Ix.DefKind) (typ value : Ixon.Expr)
+    (sharing : Array Ixon.Expr := #[]) (refs : Array Address := #[])
+    (univs : Array Ixon.Univ := #[]) : Ixon.Constant :=
+  ⟨.defn ⟨kind, .safe, 0, typ, value⟩, sharing, refs, univs⟩
+
+/-- `Sort 0` (i.e. `Prop`), resolving through `univs[0] = Univ.zero`. -/
+def prop : Ixon.Expr := .sort 0
+
+/-- The single-entry universe table `prop` indexes into. -/
+def univsZero : Array Ixon.Univ := #[.zero]
+
+/-! ## Fixtures -/
+
+/-- The constant every case in this group smuggles past the checker.
+
+    Declared type `Prop`, value the term `Prop`. `Prop : Type` (i.e.
+    `Sort 1`), NOT `Prop`, so this is ill-typed and the kernel must
+    reject it whenever it is actually checked. Its declared type is
+    nonetheless perfectly usable by `k_infer`, which reads a `Const`
+    node's DECLARED type without checking it (`Kernel/Infer.lean`). -/
+def illTypedConst : Ixon.Constant :=
+  defnConst .defn prop prop (univs := univsZero)
+
+/-- Builds the group: an ill-typed constant plus a target that depends
+    on it, where `deadSharing` decides whether the target carries a
+    `sharing` entry no `Expr.Share` node references.
+
+    `Expr.nat 0` names index 0 of `refs`, so `blob_idxs_of` records
+    index 0 as a blob payload — and `walk_refs_transitive` /
+    `env_walk_refs` skip a marked index unconditionally. The entry is
+    never converted (conversion reaches `sharing` only via
+    `Expr.Share`), never typechecked, and needs no blob on channel 4;
+    it exists purely to be seen by the blob-index pass. -/
+def dependentTarget (deadSharing : Bool) : Ixon.Env × Address :=
+  let (env, badAddr) := storeAt {} illTypedConst
+  let sharing : Array Ixon.Expr := if deadSharing then #[.nat 0] else #[]
+  -- Declared type `Prop`, value `refs[0]` — whose DECLARED type is also
+  -- `Prop`, so the target typechecks against the dependency's claim
+  -- about itself. Only walking into the dependency exposes the lie.
+  let target := defnConst .defn prop (.ref 0 #[]) sharing #[badAddr] univsZero
+  storeAt env target
+
+/-- Target whose value is `Let(Nat 0, Ref 0)`: index 0 of `refs` is named
+    by a `Nat` literal AND by a constant reference. The `Nat` use needs a
+    blob on channel 4 under the same address, which costs nothing —
+    `load_verified_blob` parses nothing, so any byte string is a valid
+    blob, and blob and constant addresses share one un-domain-separated
+    blake3 space. -/
+def bothUsedTarget : Ixon.Env × Address := Id.run do
+  let (env, badAddr) := storeAt {} illTypedConst
+  -- Seed the dependency's own serialized bytes as a blob under its own
+  -- address: `verify_bytes_against` passes because it is the same byte
+  -- string.
+  let env := { env with blobs := env.blobs.insert badAddr (Ixon.ser illTypedConst) }
+  let target := defnConst .defn prop
+    (.letE false prop (.nat 0) (.ref 0 #[])) #[] #[badAddr] univsZero
+  storeAt env target
+
+/-- A definition whose declared type is `String` and whose value is a
+    string literal over `bytes`.
+
+    `refs[0]` is the real `String` constant (used as `Ref`, so the walk
+    checks it) and `refs[1]` is the literal's blob (used as `Str`, so it
+    is a payload, not a walk target). Conversion wraps the blob in
+    `KLiteral.Str` and `k_infer_lit` types it `String` unconditionally,
+    so nothing on this path ever looks at the bytes. -/
+def strLiteralConst (strAddr blobAddr : Address) : Ixon.Constant :=
+  defnConst .defn (.ref 0 #[]) (.str 1) #[] #[strAddr, blobAddr] #[]
+
+/-- Env carrying `bytes` as a blob plus a definition asserting it is a
+    `String`, over a base env that supplies the real `String` constant. -/
+def strLiteralTarget (base : Ixon.Env) (strAddr : Address)
+    (bytes : ByteArray) : Ixon.Env × Address :=
+  let blobAddr := Address.blake3 bytes
+  let env := { base with blobs := base.blobs.insert blobAddr bytes }
+  storeAt env (strLiteralConst strAddr blobAddr)
+
+/-- A mutual block with `n` trivially well-typed members, plus the
+    projection wrapper for each so `get_ci` can resolve them.
+
+    Each member is `Sort 0 : Sort 1`, i.e. `Prop : Type`, which is
+    well-typed, so the whole block must check. With `n > 256` this
+    exercises the width of the synthesized projection index: the member
+    address is derived by serializing `DPrj{idx, block}`, so `idx` has to
+    survive the round trip at its full `u64` width. -/
+def mutsBlockOfSize (n : Nat) : Ixon.Env × Address := Id.run do
+  let member : Ixon.MutConst := .defn ⟨.defn, .safe, 0, .sort 1, .sort 0⟩
+  let block : Ixon.Constant :=
+    ⟨.muts (Array.replicate n member), #[], #[], #[.zero, .succ .zero]⟩
+  let (env, blockAddr) := storeAt {} block
+  let mut e := env
+  for i in [:n] do
+    e := (storeAt e ⟨.dPrj ⟨i.toUInt64, blockAddr⟩, #[], #[], #[]⟩).1
+  return (e, blockAddr)
+
+/-- `theorem bad : False := bad`, written directly in Ixon.
+
+    `Expr.recur 0` is the self-reference. `get_ci` hands a standalone
+    `Defn` a one-element `recur_addrs` whose only entry is the constant's
+    OWN address, and conversion erases `Rec` into an ordinary `Const`, so
+    the value becomes `Const(self)`. `k_infer` on a `Const` reads the
+    referenced constant's DECLARED type without checking it, and here the
+    referenced constant is the one being checked — whose declared type is
+    `False`. So the body typechecks against the type by citing itself.
+
+    The ref-walk cannot save this: `const_idxs_expr` deliberately does
+    not follow `Rec`, and the target of the self-reference is the
+    constant already under check. Lean's own kernel forbids exactly this
+    by checking a definition in an environment that does not yet contain
+    it, admitting self-reference only for `unsafe`. -/
+def selfReferentialTheorem (falseAddr : Address) : Ixon.Constant :=
+  ⟨.defn ⟨.thm, .safe, 0, .ref 0 #[], .recur 0 #[]⟩, #[], #[falseAddr], #[]⟩
+
+/-! ### Recursor rule right-hand sides
+
+`compare_rules` peels the binders off the STORED rule and uses that
+term's own `Lam` domains as the local context for the def-eq against the
+canonical reconstruction. Those domains are prover-authored and are never
+checked, so they decide what the comparison's two sides infer to.
+
+Rather than hand-build a recursor — its declared type has to survive
+`build_rec_type`'s def-eq, and constructor references inside a block are
+circular with the block's own address — these take a REAL compiled block
+and rewrite only a rule's right-hand side. Everything else stays exactly
+as the compiler emitted it. -/
+
+/-- The `Muts` block a projection wrapper points at. -/
+def blockOfWrapper (env : Ixon.Env) (wrapper : Address) :
+    Option (Address × Ixon.Constant) := do
+  let c ← env.getConst? wrapper
+  let blockAddr ← match c.info with
+    | .iPrj p | .cPrj p | .rPrj p | .dPrj p => some p.block
+    | _ => none
+  let block ← env.getConst? blockAddr
+  some (blockAddr, block)
+
+/-- A block carrying a recursor with at least two rules, chosen
+    deterministically by address so the fixture does not depend on hash
+    iteration order. Recursors do not necessarily share their inductive's
+    block, so this searches rather than following a wrapper. -/
+def findRecrBlock (env : Ixon.Env) : Option Ixon.Constant := Id.run do
+  let mut best : Option (Address × Ixon.Constant) := none
+  for (addr, lc) in env.consts do
+    if let some c := lc.get? then
+      -- A non-mutual recursor is a STANDALONE `Recr` constant, not a
+      -- `Muts` member; accept either shape.
+      -- Require every rule to be field-free. A rule with fields has a
+      -- body that APPLIES its minor premise, so retyping that binder to
+      -- a Prop makes it a non-function and the run aborts before the
+      -- comparison — which would mask the acceptance being probed.
+      let usable (r : Ixon.Recursor) : Bool :=
+        r.rules.size ≥ 2 && r.rules.all (fun rule => rule.fields == 0)
+      let hasRules : Bool := match c.info with
+        | .recr r => usable r
+        | .muts members => members.any fun m =>
+            match m with | .recr r => usable r | _ => false
+        | _ => false
+      if hasRules then
+        match best with
+        | none => best := some (addr, c)
+        | some (a, _) => if addr.hash.data < a.hash.data then best := some (addr, c)
+  return best.map (·.2)
+
+/-- Replace the outermost `n+1` binder DOMAINS of a rule right-hand side
+    with `dom`, keeping its body and binder count. The kernel peels
+    exactly these binders and adopts their domains as the context it
+    infers through. -/
+partial def retypeBinders (n : Nat) (dom : Ixon.Expr) : Ixon.Expr → Ixon.Expr
+  | .lam _ body => if n == 0 then .lam dom body
+                   else .lam dom (retypeBinders (n - 1) dom body)
+  | e => e
+
+/-- Swap the right-hand sides of the recursor's first two rules, so each
+    constructor reduces to the other's branch — wrong under any reading.
+    When `retype` is given, also replace the outermost `nBinders` binder
+    DOMAINS of each rule with it. -/
+def corruptRecrRules (c : Ixon.Constant) (nBinders : Nat)
+    (retype : Option Ixon.Expr) : Ixon.Constant :=
+  let corruptOne (r : Ixon.Recursor) : Ixon.Recursor :=
+    if r.rules.size < 2 then r else
+    let a := r.rules[0]!
+    let b := r.rules[1]!
+    let swapped :=
+      #[{ a with rhs := b.rhs }, { b with rhs := a.rhs }]
+        ++ r.rules.extract 2 r.rules.size
+    { r with rules := match retype with
+        | none => swapped
+        | some d => swapped.map fun rule =>
+            { rule with rhs := retypeBinders nBinders d rule.rhs } }
+  match c.info with
+  | .recr r => { c with info := .recr (corruptOne r) }
+  | .muts members =>
+    { c with info := .muts <| members.map fun m =>
+        match m with
+        | .recr r => .recr (corruptOne r)
+        | other => other }
+  | _ => c
+
+/-! ### Byte-level encodings
+
+Every other fixture here is built from an `Ixon.Constant` VALUE and
+addressed via `Ixon.ser`, which always emits canonical bytes — so no such
+fixture can express a non-canonical ENCODING. These store hand-authored
+bytes directly, which is what a prover actually controls. -/
+
+/-- Store a hand-authored byte string as a constant at its own content
+    address. `addEntries` seeds channel 2 from `rawBytes`, so the kernel
+    faults exactly these bytes, blake3-verifies them against the key, and
+    parses them with the in-circuit parser. -/
+def storeRawAt (env : Ixon.Env) (bytes : ByteArray) : Ixon.Env × Address :=
+  let addr := Address.blake3 bytes
+  ({ env with
+      consts := env.consts.insert addr
+        (Ixon.LazyConstant.ofSlice bytes 0 bytes.size) }, addr)
+
+/-- Rewrite the one-byte canonical `Tag0` at `off` as an OVERLONG
+    encoding of the same value: head `0x88` announces nine payload bytes,
+    then eight zeros and one trailing byte.
+
+    `Tag0`'s `small` field is 7 bits, so a payload width of 9 is
+    expressible and unguarded. The in-circuit `get_u64_le` consumes all
+    nine and keeps the first eight, discarding the ninth; the Lean host
+    folds it back in (its shift is taken mod 64, and it has no length
+    guard); Rust rejects `len > 8` outright. Same bytes, same address,
+    three readings. -/
+def overlongTag0At (bytes : ByteArray) (off : Nat) (trailing : UInt8) :
+    ByteArray :=
+  bytes.extract 0 off
+    ++ (⟨#[0x88, 0, 0, 0, 0, 0, 0, 0, 0, trailing]⟩ : ByteArray)
+    ++ bytes.extract (off + 1) bytes.size
+
+/-- An axiom `_ : Prop`. Serializes as
+    `[0xD2][isUnsafe][lvls Tag0][typ…][sharing][refs][univs]`, so the
+    `lvls` `Tag0` is at byte 2 — the field the overlong rewrite targets. -/
+def propAxiom : Ixon.Constant :=
+  ⟨.axio ⟨false, 0, .sort 0⟩, #[], #[], #[.zero]⟩
+
+/-! ### Canonicality of computed Nat literals
+
+`klimbs_eq` — which backs `Nat.beq`, `Nat.decEq` and `literal_eq` — is a
+raw limb-by-limb compare with no normalization, so it distinguishes two
+`KLimbs` that denote the same natural. Any reducer that emits a
+non-canonical literal therefore makes `Nat.beq` disagree with Lean. -/
+
+/-- `theorem _ : Nat.beq (String.utf8ByteSize "") 0 = rhs := Eq.refl Bool rhs`
+
+    Reduction of the left side is what the kernel has to get right; the
+    proof is `rfl`, so the declaration typechecks exactly when the kernel
+    reduces the equation's two sides to the same value.
+
+    `refs[4]` is the empty blob, used both as the string literal `""` and
+    as the nat literal `0` — the same bytes read two ways, which is
+    exactly what the Expr context is for. -/
+def utf8SizeBeq (eqA boolA beqA sizeA blobA rhsA reflA : Address) :
+    Ixon.Constant :=
+  let lhs : Ixon.Expr :=
+    .app (.app (.ref 2 #[]) (.app (.ref 3 #[]) (.str 4))) (.nat 4)
+  let typ : Ixon.Expr :=
+    .app (.app (.app (.ref 0 #[0]) (.ref 1 #[])) lhs) (.ref 5 #[])
+  let val : Ixon.Expr := .app (.app (.ref 6 #[0]) (.ref 1 #[])) (.ref 5 #[])
+  ⟨.defn ⟨.thm, .safe, 0, typ, val⟩, #[],
+   #[eqA, boolA, beqA, sizeA, blobA, rhsA, reflA], #[.succ .zero]⟩
+
+/-! ### Nested-inductive positivity
+
+Two single-inductive blocks in `Prop`. The outer one takes the inner
+applied to ITSELF as its constructor's field, so whether the outer is
+positive depends entirely on where its own type lands inside the inner
+one's constructor — i.e. on the nested check substituting the parameter
+arguments before looking. -/
+
+/-- A one-inductive block `P (α : Prop) : Prop | mk : field → P α`, where
+    `field` is written under two binders (`α`, then the field itself). -/
+def paramInductiveBlock (refs : Array Address) (field : Ixon.Expr) :
+    Ixon.Constant :=
+  let mkTyp : Ixon.Expr :=
+    .all (.sort 0) (.all field (.app (.recur 0 #[]) (.var 1)))
+  let ind : Ixon.Inductive :=
+    ⟨false, 0, 1, 0, .all (.sort 0) (.sort 0), #[⟨false, 0, 0, 1, 1, mkTyp⟩]⟩
+  ⟨.muts #[.indc ind], #[], refs, #[.zero]⟩
+
+/-- `Host : Prop | mk : Inner Host → Host`, where `Inner` is `refs[0]`. -/
+def hostBlock (innerAddr : Address) : Ixon.Constant :=
+  let mkTyp : Ixon.Expr :=
+    .all (.app (.ref 0 #[]) (.recur 0 #[])) (.recur 0 #[])
+  let ind : Ixon.Inductive :=
+    ⟨false, 0, 0, 0, .sort 0, #[⟨false, 0, 0, 0, 1, mkTyp⟩]⟩
+  ⟨.muts #[.indc ind], #[], #[innerAddr], #[.zero]⟩
+
+/-- Store a single-inductive block plus the projection wrappers `get_ci`
+    resolves its member and constructor through. Returns the env and the
+    inductive's wrapper address. -/
+def storeInductive (env : Ixon.Env) (block : Ixon.Constant) :
+    Ixon.Env × Address := Id.run do
+  let (env, blockAddr) := storeAt env block
+  let (env, indAddr) := storeAt env ⟨.iPrj ⟨0, blockAddr⟩, #[], #[], #[]⟩
+  let (env, _) := storeAt env ⟨.cPrj ⟨0, 0, blockAddr⟩, #[], #[], #[]⟩
+  return (env, indAddr)
+
+/-- `Host` over an inner inductive whose constructor field is `innerField`
+    (written under the inner's own two binders). Returns the env and
+    `Host`'s wrapper address. -/
+def nestedHost (base : Ixon.Env) (innerRefs : Array Address)
+    (innerField : Ixon.Expr) : Ixon.Env × Address :=
+  let (env, innerAddr) :=
+    storeInductive base (paramInductiveBlock innerRefs innerField)
+  storeInductive env (hostBlock innerAddr)
+
+def cases (base : Ixon.Env) (strAddr falseAddr : Address)
+    (eqA boolA beqA sizeA trueA falseBoolA reflA : Address) :
+    Array ExploitCase := Id.run do
+  -- `""` and `0` share one blob: both are the empty byte string.
+  let emptyBlob : ByteArray := ⟨#[]⟩
+  let blobA := Address.blake3 emptyBlob
+  let blobEnv := { base with blobs := base.blobs.insert blobA emptyBlob }
+  let (beqTrueEnv, beqTrueAddr) :=
+    storeAt blobEnv (utf8SizeBeq eqA boolA beqA sizeA blobA trueA reflA)
+  let (beqFalseEnv, beqFalseAddr) :=
+    storeAt blobEnv (utf8SizeBeq eqA boolA beqA sizeA blobA falseBoolA reflA)
+  -- Recursor-rule fixtures, built from `Bool`'s real compiled block:
+  -- two nullary constructors, so each rule's binders are exactly
+  -- (motive, minor, minor) and swapping the two right-hand sides makes
+  -- each constructor reduce to the other's branch.
+  let recrCases : Array ExploitCase :=
+    match findRecrBlock base with
+    | none =>
+      -- Never silently skip: no recursor block means the fixture is not
+      -- exercising `compare_rules` at all.
+      #[{ name := "recursor-fixture-found-no-recursor-block"
+          intent := "the fixture must locate a recursor with >= 2 rules"
+          env := base, claim := .check falseAddr none
+          expectAccept := true }]
+    | some block =>
+      -- Both variants carry the same extended refs table, so the only
+      -- difference between them is the binder domains.
+      let refIdx := block.refs.size.toUInt64
+      let block := { block with refs := block.refs.push falseAddr }
+      let mk (retype : Option Ixon.Expr) : Ixon.Env × Address := Id.run do
+        let (env, blockAddr) := storeAt base (corruptRecrRules block 2 retype)
+        let mut e := env
+        for i in [:2] do
+          e := (storeAt e ⟨.iPrj ⟨i.toUInt64, blockAddr⟩, #[], #[], #[]⟩).1
+          e := (storeAt e ⟨.rPrj ⟨i.toUInt64, blockAddr⟩, #[], #[], #[]⟩).1
+          e := (storeAt e ⟨.cPrj ⟨i.toUInt64, 0, blockAddr⟩, #[], #[], #[]⟩).1
+          e := (storeAt e ⟨.cPrj ⟨i.toUInt64, 1, blockAddr⟩, #[], #[], #[]⟩).1
+        return (e, blockAddr)
+      let (honestEnv, honestAddr) := mk none
+      let (doctoredEnv, doctoredAddr) := mk (some (.ref refIdx #[]))
+      #[
+        -- CONTROL: swapped rules with the compiler's own binder domains.
+        -- The comparison then infers through honest types and the
+        -- mismatch is caught.
+        { name := "control-swapped-recursor-rules"
+          intent := "a recursor whose two rules are swapped, with honest \
+            binder domains — must be rejected"
+          env := honestEnv, claim := .check honestAddr none },
+        -- The same swap, with every peeled binder domain replaced by a
+        -- Prop. `compare_rules` adopts those domains as the context it
+        -- infers through, so both sides type as that Prop and proof
+        -- irrelevance accepts any body.
+        { name := "recursor-rule-rhs-doctored-binder-domains"
+          intent := "a recursor accepted with swapped computation rules, \
+            because the rule's own binder domains chose the context the \
+            comparison infers through"
+          env := doctoredEnv, claim := .check doctoredAddr none }
+      ]
+  let axiomBytes := Ixon.ser propAxiom
+  let (canonBytesEnv, canonBytesAddr) := storeRawAt base axiomBytes
+  let (overlongEnv, overlongAddr) :=
+    storeRawAt base (overlongTag0At axiomBytes 2 0x2A)
+  -- `Inner α | mk : α → Inner α` — α strictly positive. `Host` is fine.
+  let (posEnv, posAddr) := nestedHost base #[] (.var 0)
+  -- `Inner α | mk : (α → False) → Inner α` — α NEGATIVE. Substituting
+  -- `α := Host` turns Host's field into `(Host → False) → …`, so `Host`
+  -- must be rejected.
+  let (negEnv, negAddr) :=
+    nestedHost base #[falseAddr] (.all (.var 0) (.ref 0 #[]))
+  let (selfRefEnv, selfRefAddr) := storeAt base (selfReferentialTheorem falseAddr)
+  let (smallBlockEnv, smallBlockAddr) := mutsBlockOfSize 2
+  let (bigBlockEnv, bigBlockAddr) := mutsBlockOfSize 257
+  -- 0xFF can never appear in well-formed UTF-8; `String::from_utf8`
+  -- rejects it, and so must the kernel.
+  let (badUtf8Env, badUtf8Addr) :=
+    strLiteralTarget base strAddr ⟨#[0xFF]⟩
+  let (okUtf8Env, okUtf8Addr) :=
+    strLiteralTarget base strAddr ⟨#[0x68, 0x69]⟩
+  let (badEnv, badAddr) := storeAt {} illTypedConst
+  let (plainEnv, plainAddr) := dependentTarget (deadSharing := false)
+  let (deadEnv, deadAddr) := dependentTarget (deadSharing := true)
+  let (bothEnv, bothAddr) := bothUsedTarget
+  let selfTree := (Ix.AssumptionTree.canonical #[badAddr]).get!
+  let selfTrees : Std.HashMap Address Ix.AssumptionTree :=
+    ({} : Std.HashMap Address Ix.AssumptionTree).insert selfTree.root selfTree
+  #[
+    -- CONTROL: the smuggled constant is genuinely ill-typed. If this
+    -- ever passes, the exploit below proves nothing.
+    { name := "control-ill-typed-dep-alone"
+      intent := "`Prop : Prop` — a definition whose value's type is \
+        `Sort 1`, not its declared `Sort 0`"
+      env := badEnv, claim := .check badAddr none },
+    -- CONTROL: without the trick the ref-walk reaches the dependency
+    -- and rejects. Differs from the exploit ONLY in `sharing`.
+    { name := "control-dep-walked-without-dead-sharing"
+      intent := "a definition whose dependency is ill-typed, with \
+        nothing suppressing the ref-walk"
+      env := plainEnv, claim := .check plainAddr none },
+    -- EXPLOIT: one dead `sharing` entry marks the dependency's refs
+    -- index as a blob payload, so the walk skips it. The kernel then
+    -- accepts a constant whose transitive closure is ill-typed.
+    { name := "dead-sharing-entry-suppresses-ref-walk"
+      intent := "a definition accepted as well-typed while its \
+        transitive closure contains an ill-typed constant that was \
+        never checked"
+      env := deadEnv, claim := .check deadAddr none },
+    -- The same dependency reached through an index used as BOTH a `Nat`
+    -- literal and a `Ref`. `refs` is one index space and the entries are
+    -- deduplicated by address, so the two uses can share an index; under
+    -- the old blob-exclusion rule the `Nat` use would have suppressed the
+    -- `Ref` walk. Rejected, though by abort rather than by the type
+    -- error: the positive rule admits the index, and treating one address
+    -- as both a constant and a blob payload trips a channel fault first.
+    -- That is the safe direction — an abort only costs a dishonest prover.
+    { name := "index-used-as-both-nat-and-ref"
+      intent := "a definition whose ill-typed dependency is hidden \
+        behind an index that also carries a Nat literal"
+      env := bothEnv, claim := .check bothAddr none },
+    -- BOUNDARY, not a kernel bug: assumption sets are prover-supplied,
+    -- and naming the claim's own target as its own assumption makes the
+    -- walk exit immediately, so an ill-typed constant is accepted. The
+    -- kernel is right to accept: `some root` means "conditional on every
+    -- leaf being well-typed" (`Ix/Claim.lean`), so this claim asserts
+    -- `A → A`, which is vacuously true rather than false.
+    --
+    -- The obligation therefore sits with whoever DISCHARGES assumptions:
+    -- a conditional claim must never discharge its own target, and an
+    -- aggregation of such claims must reject cycles. Sharded CheckEnv is
+    -- not exposed — `shardClaimDigest` recomputes the claim from
+    -- (env, blocks), so a prover-chosen frontier fails the digest — but
+    -- a bare Check claim carries whatever assumptions its prover picked.
+    -- Pinned as ACCEPT so the day a cycle guard lands anywhere on this
+    -- path, this case turns red and gets re-examined deliberately.
+    { name := "self-assumption-covers-claim-target"
+      intent := "an ill-typed constant accepted under a claim that \
+        assumes precisely itself — vacuous (A → A), so sound as a claim; \
+        the cycle must be rejected when assumptions are discharged"
+      env := badEnv, claim := .check badAddr (some selfTree.root)
+      trees := selfTrees, expectAccept := true },
+    -- CONTROL: the same shape over well-formed UTF-8 must typecheck, so
+    -- a rejection below is attributable to the bytes and not to the
+    -- fixture's shape.
+    { name := "control-valid-utf8-string-literal"
+      intent := "a well-formed `String` literal, which must be accepted"
+      env := okUtf8Env, claim := .check okUtf8Addr none
+      expectAccept := true },
+    -- `Expr.Str` conversion wraps any hash-valid blob in `KLiteral.Str`
+    -- and `k_infer_lit` types it `String` without inspecting the bytes,
+    -- so a literal that is not valid UTF-8 typechecks. The reference
+    -- kernel rejects it at ingress (`String::from_utf8`), and no Lean
+    -- `String` corresponds to these bytes, so accepting is a wrong
+    -- answer. The UTF-8 validation on the string DECODER does not cover
+    -- this: ordinary checking of a literal never decodes it.
+    { name := "invalid-utf8-accepted-as-string"
+      intent := "a definition accepted as `x : String` whose literal is \
+        not valid UTF-8, which the reference kernel rejects"
+      env := badUtf8Env, claim := .check badUtf8Addr none },
+    -- CONTROL: the same block shape below the index width, to show the
+    -- fixture's members and wrappers are well-formed.
+    { name := "control-small-muts-block"
+      intent := "a two-member mutual block of well-typed definitions, \
+        which must be accepted"
+      env := smallBlockEnv, claim := .check smallBlockAddr none
+      expectAccept := true },
+    -- Member and constructor indices are synthesized into the projection
+    -- wrapper's `u64` field, whose bytes `idx_to_u64` obtains from a hint
+    -- and constrains to recompose to the index. A block past the former
+    -- single-byte range is otherwise valid and must check.
+    { name := "muts-block-past-single-byte-index"
+      intent := "a valid 257-member mutual block, which must be \
+        checkable rather than rejected for its size"
+      env := bigBlockEnv, claim := .check bigBlockAddr none
+      expectAccept := true },
+    -- The sharpest statement available: accepting this is a proof of
+    -- `False`.
+    { name := "self-referential-theorem-proves-false"
+      intent := "`theorem bad : False := bad` accepted as well-typed — a \
+        proof of False, since the body is the constant itself"
+      env := selfRefEnv, claim := .check selfRefAddr none },
+    -- CONTROL: nesting through a strictly-positive inductive is fine and
+    -- must keep checking, so a rejection below is attributable to the
+    -- negative occurrence rather than to nesting itself.
+    { name := "control-nested-positive-inductive"
+      intent := "`Host | mk : Inner Host → Host` where `Inner α | mk : α \
+        → Inner α` is strictly positive — must be accepted"
+      env := posEnv, claim := .check posAddr none
+      expectAccept := true },
+    -- The nested positivity check drops the parameter arguments
+    -- (`list_drop(args, n_ctor_params)`) and descends into the inner
+    -- inductive's constructors WITHOUT substituting them. The inner
+    -- constructor's field mentions its parameter as a `BVar`, so the
+    -- block-occurrence test sees nothing and passes vacuously — exactly
+    -- the positions that matter. Both references substitute first.
+    { name := "nested-inductive-negative-occurrence"
+      intent := "an inductive accepted despite occurring negatively \
+        through a nested inductive's parameter — admits `False`"
+      env := negEnv, claim := .check negAddr none },
+    -- CONTROL: the TRUE equation. `"".utf8ByteSize` is 0, so `Nat.beq`
+    -- of it against 0 is `true` and this must check.
+    { name := "control-utf8-size-beq-true"
+      intent := "`Nat.beq (String.utf8ByteSize \"\") 0 = true`, which is \
+        true in Lean and must be accepted"
+      env := beqTrueEnv, claim := .check beqTrueAddr none
+      expectAccept := true },
+    -- `bytestream_length_u64` builds the length as a single unchecked
+    -- byte with no `klimbs_normalize`, so the empty string's size is the
+    -- DENORMALIZED zero `[[0;8]]` rather than the canonical empty limb
+    -- list. `klimbs_eq` compares limbs without normalizing, so `Nat.beq`
+    -- answers `false` where Lean answers `true`, and the false equation
+    -- typechecks by `rfl`.
+    { name := "utf8-size-beq-false-accepted"
+      intent := "`Nat.beq (String.utf8ByteSize \"\") 0 = false` accepted \
+        by rfl — a false equation, since the size really is 0"
+      env := beqFalseEnv, claim := .check beqFalseAddr none }
+  ] ++ recrCases ++ #[
+    -- CONTROL: the same axiom with CANONICAL bytes, stored raw through
+    -- the same path. Establishes that the constant is well-formed and
+    -- that raw-byte storage works, so a rejection below is attributable
+    -- to the encoding alone.
+    { name := "control-canonical-tag0-axiom"
+      intent := "an axiom `_ : Prop` with canonical bytes, which must be \
+        accepted"
+      env := canonBytesEnv, claim := .check canonBytesAddr none
+      expectAccept := true },
+    -- The same axiom with its `lvls` Tag0 written overlong. No host will
+    -- accept these bytes — Rust rejects the width outright and the Lean
+    -- host reads a different value — so the kernel accepting them means
+    -- its accepted language is strictly wider than the format, and one
+    -- address denotes different constants to different readers.
+    { name := "overlong-tag0-accepted"
+      intent := "a constant accepted from a non-canonical Tag0 encoding \
+        that Rust rejects and the Lean host reads differently"
+      env := overlongEnv, claim := .check overlongAddr none }
+  ]
+
+/-! ## Runner -/
+
+/-- Run every case against the compiled `IxVM.ixVM` toplevel through the
+    `verify_claim` entrypoint (the production claim path — never the
+    `verify_const` debug entrypoint, whose whole contract is to trust
+    dependencies). -/
+def exploitTests (leanEnv : Lean.Environment)
+    (compiled : Aiur.CompiledToplevel) : IO TestSeq := do
+  let funIdx ← match compiled.getFuncIdx `verify_claim with
+    | some i => pure i
+    | none => throw <| IO.userError "verify_claim entrypoint missing"
+  -- Cases that assert something about `String` need the real `String`
+  -- constant to declare a type against; everything else is built from
+  -- nothing.
+  let base ← IxVM.ClaimHarness.loadSharedIxonEnv
+    #[``String, ``False, ``Eq, ``Eq.refl, ``Bool, ``Nat.beq,
+      ``String.utf8ByteSize] leanEnv
+  let strAddr ← IxVM.ClaimHarness.lookupAddr base ``String
+  let falseAddr ← IxVM.ClaimHarness.lookupAddr base ``False
+  let eqA ← IxVM.ClaimHarness.lookupAddr base ``Eq
+  let boolA ← IxVM.ClaimHarness.lookupAddr base ``Bool
+  let beqA ← IxVM.ClaimHarness.lookupAddr base ``Nat.beq
+  let sizeA ← IxVM.ClaimHarness.lookupAddr base ``String.utf8ByteSize
+  let trueA ← IxVM.ClaimHarness.lookupAddr base ``Bool.true
+  let falseBoolA ← IxVM.ClaimHarness.lookupAddr base ``Bool.false
+  let reflA ← IxVM.ClaimHarness.lookupAddr base ``Eq.refl
+  let mut tests : TestSeq := .done
+  for c in cases base strAddr falseAddr eqA boolA beqA sizeA trueA
+             falseBoolA reflA do
+    let verdict := if c.expectAccept then "ACCEPT" else "REJECT"
+    let label := s!"exploit {verdict} {c.name}"
+    match IxVM.ClaimHarness.buildClaimWitness c.env c.claim c.trees with
+    | .error e =>
+      -- A witness that will not build is a broken fixture, not a
+      -- kernel verdict; never let it read as a pass.
+      tests := tests ++ test s!"{label}: witness build failed ({e})" false
+    | .ok witness =>
+      match compiled.bytecode.execute funIdx witness.input witness.inputIOBuffer with
+      | .ok _ =>
+        tests := tests ++
+          test s!"{label} (accepted — buys: {c.intent})" c.expectAccept
+      | .error e =>
+        -- Surface the rejection reason. A case can pass for the WRONG
+        -- reason — a malformed fixture that aborts before it reaches
+        -- the mechanism under attack looks identical to a kernel that
+        -- correctly refuses the exploit. Print it so the author can
+        -- confirm the assert that fired is the intended one.
+        IO.println s!"  [{c.name}] rejected by: {e}"
+        tests := tests ++ test label (!c.expectAccept)
+  return tests
+
+end Tests.Ix.IxVM.Exploits
diff --git a/Tests/Ix/Kernel/Arena.lean b/Tests/Ix/Kernel/Arena.lean
index aa531c43d..5038eb23b 100644
--- a/Tests/Ix/Kernel/Arena.lean
+++ b/Tests/Ix/Kernel/Arena.lean
@@ -1,7 +1,7 @@
 /-
   Drives the Aiur kernel through every lean-kernel-arena tutorial
   fixture (`Tests.Ix.Kernel.TutorialDefs` + `NatReduction`) using the
-  shared `IxVM.ixVM` toplevel + `verify_const` entrypoint.
+  shared `IxVM.ixVMFull` toplevel + `verify_const` entrypoint.
 
   Each fixture's outcome is classified against the test case's expected
   outcome (good must typecheck; bad must be rejected via Aiur execution
@@ -108,7 +108,7 @@ private def buildInput (ixonEnv : Ixon.Env) (name : Lean.Name) :
     .ok (witness.input, witness.inputIOBuffer)
 
 /-- Run the arena suite against `compiled` (already-compiled Aiur
-    `IxVM.ixVM` toplevel) using a single shared Ixon env. Returns one
+    `IxVM.ixVMFull` toplevel) using a single shared Ixon env. Returns one
     `TestSeq` entry per fixture. -/
 def arenaTests (env : Lean.Environment)
     (compiled : Aiur.CompiledToplevel) : IO TestSeq := do
@@ -140,8 +140,21 @@ def arenaTests (env : Lean.Environment)
         tests := tests ++
           test label (c.expectPass)
       | .error e =>
+        -- A `bad_*` fixture counts as correctly rejected only when the
+        -- kernel actually REFUSED it. `assert_eq!` failures qualify, and
+        -- so do unmatched-match aborts: this kernel deliberately relies
+        -- on an unmatched runtime value aborting rather than spending
+        -- circuit width on `_ => assert_eq!(0, 1)` arms, so "no match
+        -- case for value N" is a verdict too.
+        --
+        -- `invalid IO key` is NOT. It means the witness never supplied
+        -- the bytes, so execution died before reaching the logic under
+        -- test — scoring it as a rejection is how a fixture rots into a
+        -- green test that checks nothing. No fixture currently relies on
+        -- it; this keeps it that way.
+        let refused := (e.splitOn "invalid IO key").length == 1
         tests := tests ++
-          test s!"{label} ({e})" (!c.expectPass)
+          test s!"{label} ({e})" (!c.expectPass && refused)
   return tests
 
 end Tests.Ix.Kernel.Arena
diff --git a/Tests/Ix/Kernel/PrimAddrs.lean b/Tests/Ix/Kernel/PrimAddrs.lean
new file mode 100644
index 000000000..68f638e96
--- /dev/null
+++ b/Tests/Ix/Kernel/PrimAddrs.lean
@@ -0,0 +1,149 @@
+/-
+  Guards the kernel's hardcoded primitive addresses against the
+  canonical table.
+
+  The Aiur kernel hardcodes ~77 primitive constant addresses as 32-byte
+  literals (`fn nat_add_addr() -> Addr { store([0xd6u8, ...]) }`) so
+  reduction can recognize `Nat.add` etc. by address alone. Those bytes
+  are the kernel's entire notion of "this Const IS the primitive whose
+  semantics I am about to substitute", so a single wrong byte is a
+  soundness-relevant defect: the kernel either fails to recognize a
+  primitive (incompleteness) or — worse — recognizes the WRONG constant
+  and applies native semantics to it.
+
+  Such a defect is invisible to the FFT-pinned suite and to the arena
+  fixtures: a corrupted literal simply never matches, so well-typed
+  targets still check and ill-typed ones still fail. One shipped for
+  months (`bool_false_addr`, last 8 bytes wrong) and only surfaced when
+  a new reduction path finally tried to emit `Bool.false`.
+
+  This test closes that class. It reads the byte arrays out of the
+  ELABORATED toplevel — not the source text — and compares each against
+  the address computed at test runtime from `Ix.Tc.PrimAddrs`, which is
+  the same table the host-side closure walker and ingress verifier use.
+  Any drift between the two sources of truth fails here.
+
+  Coverage is by construction: every `fn <name>() -> Addr` in the
+  toplevel whose body is a 32-byte literal must resolve to a canonical
+  address, and the test reports the count so a silent drop to zero
+  (e.g. an AST shape change) cannot pass unnoticed.
+-/
+import Ix.Meta
+import Ix.Aiur.Compiler
+import Ix.IxVM
+import Ix.IxVM.Toplevel
+import Ix.Tc.Primitive
+import LSpec
+
+open LSpec
+
+namespace Tests.Ix.Kernel.PrimAddrs
+
+/-- Read a 32-byte address literal out of an elaborated function body.
+    Recognizes exactly the shape the addr helpers use:
+    `store([b0u8, …, b31u8])`. Anything else → `none` (the function is
+    not an address constant). -/
+private def addrLiteralOf (body : Aiur.Source.Term) : Option Address :=
+  match body with
+  | .store (.array elts) | .array elts =>
+    if elts.size != 32 then none else Id.run do
+      let mut bytes : Array UInt8 := Array.mkEmpty 32
+      for e in elts do
+        match e with
+        | .u8Lit n => bytes := bytes.push (UInt8.ofNat n)
+        | _ => return none
+      return some ⟨⟨bytes⟩⟩
+  | _ => none
+
+/-- Every `fn <name>() -> Addr`-shaped constant in the toplevel, paired
+    with the address its literal encodes. -/
+private def collectAddrFns (t : Aiur.Source.Toplevel) :
+    Array (String × Address) := Id.run do
+  let mut out : Array (String × Address) := #[]
+  for f in t.functions do
+    if !f.inputs.isEmpty then continue
+    if let some a := addrLiteralOf f.body then
+      out := out.push (f.name.toName.toString, a)
+  return out
+
+/-- The canonical address set, computed at test runtime from the Lean
+    parity table + reserved markers — the same source the host closure
+    walker (`Ix.Tc.primAddrSet`) consults. -/
+private def canonical : Std.HashMap Address String := Id.run do
+  let mut m : Std.HashMap Address String := {}
+  for (name, a) in Ix.Tc.PrimAddrs.leanParityTable do
+    m := m.insert a name
+  for (name, a) in Ix.Tc.PrimAddrs.reservedMarkerAddrs do
+    m := m.insert a name
+  return m
+
+/-- Fold a name to a comparison key: drop namespace separators and
+    underscores, lowercase. `nat_add_addr` and `Nat.add` both become
+    `natadd`. -/
+private def normKey (s : String) : String :=
+  ((s.replace "_" "").replace "." "").toLower
+
+private def dropSuffix (s suf : String) : String :=
+  if s.endsWith suf then (s.dropEnd suf.length).toString else s
+
+/-- The addr function's key: last namespace component, with the
+    dispatch-site suffix (`_dec`/`_io`/`_iota` — several primitives have
+    one addr function per call site), the `_addr` marker, and a trailing
+    `_type`/`_ty` removed, then normalized. `str` is spelled out, since
+    the kernel abbreviates `String`. -/
+private def fnKey (fnName : String) : String :=
+  let base := (fnName.splitOn ".").getLast!
+  let base := ["_dec", "_io", "_iota"].foldl dropSuffix base
+  let base := dropSuffix base "_addr"
+  let base := ["_type", "_ty"].foldl dropSuffix base
+  let k := normKey base
+  if k == "str" || (k.startsWith "str" && !k.startsWith "string")
+  then "string" ++ k.drop 3 else k
+
+/-- Addr functions whose name does not follow `snake_case` of the Lean
+    constant even after the normalizations above. Maps the function's key
+    to the constant it must resolve to; anything absent is required to
+    match by normalized name. -/
+private def nameExceptions : Std.HashMap String String := .ofList [
+  ("quotctor", "Quot.mk"),
+  ("quotlift", "Quot.lift"),
+  ("quotind", "Quot.ind")
+]
+
+def suite : List TestSeq := Id.run do
+  let some toplevel := (IxVM.ixVMFull).toOption
+    | [test "IxVM toplevel builds" false]
+  let fns := collectAddrFns toplevel
+  let mut tests : TestSeq :=
+    -- Guard against the extractor silently matching nothing (e.g. an
+    -- AST shape change): the kernel is known to carry dozens of these.
+    test s!"found {fns.size} address literals (expect ≥ 60)" (fns.size ≥ 60)
+  for (fnName, addr) in fns do
+    match canonical[addr]? with
+    | some canonName =>
+      -- Assert the function resolves to the constant its NAME claims.
+      -- Membership alone is not enough: this map is keyed by address, so
+      -- a table where `nat_add_addr` held `Nat.mul`'s bytes would still
+      -- find a canonical entry and pass. That permutation is precisely
+      -- the defect this suite exists to catch — the kernel would apply
+      -- one primitive's native semantics under another's name.
+      -- The addr function may spell the constant fully (`nat_add_addr` ↔
+      -- `Nat.add`) or only its final component (`reduce_bool_addr` ↔
+      -- `Lean.reduceBool`); both are accepted, anything else must be
+      -- declared in `nameExceptions`.
+      let k := fnKey fnName
+      let ok : Bool := match nameExceptions[k]? with
+        | some want => canonName == want
+        | none => k == normKey canonName || k == fnKey canonName
+      tests := tests ++ test s!"{fnName} = {canonName}" ok
+    | none =>
+      -- A named address constant that matches no canonical address is
+      -- the defect this test exists for: the kernel will never
+      -- recognize the primitive it thinks it encodes. Report the bytes.
+      -- (Sentinel fillers must be written inline, not as named addr
+      -- functions — see the zero-Addr tuple returns in Whnf/DefEq.)
+      tests := tests ++
+        test s!"{fnName}: {addr} not in canonical primitive table" false
+  return [tests]
+
+end Tests.Ix.Kernel.PrimAddrs
diff --git a/Tests/Ix/Kernel/TutorialDefs.lean b/Tests/Ix/Kernel/TutorialDefs.lean
index c0f388f0a..f251de112 100644
--- a/Tests/Ix/Kernel/TutorialDefs.lean
+++ b/Tests/Ix/Kernel/TutorialDefs.lean
@@ -1337,4 +1337,216 @@ good_raw_consts
   dummyRecInfo f
   ]
 
+/-! ## Kernel-check regression fixtures
+
+Each fixture below targets one dropped check. They are written as raw
+`ConstantInfo`s because the badness is not expressible in Lean source —
+the elaborator rejects all three before a declaration exists — and
+because `addConstInfos` admits them under `debug.skipKernelTC`.
+
+Every name in a `bad_raw_consts` case is required to be REJECTED (see
+`Arena.collectChecks`), so shared helper inductives stay outside the
+case: `r7RetHeadBad` borrows `Nat` as its foreign return head, and the
+eta fixture depends on the ordinary `EtaRecStruct` declared below. -/
+
+-- A ctor whose declared return type heads a DIFFERENT inductive (`Nat`)
+-- than the one it belongs to. `check_ctor_return_type` constrained the
+-- head only to be some `Const` of matching universe arity, so this was
+-- accepted; `assert_return_head_is_parent` now pins it to the parent.
+bad_raw_consts
+  let n := `r7RetHeadBad
+  #[ .inductInfo {
+      name := n
+      levelParams := []
+      type := .sort 1
+      numParams := 0
+      numIndices := 0
+      all := [n]
+      ctors := [n ++ `mk]
+      numNested := 0
+      isRec := false
+      isUnsafe := false
+      isReflexive := false
+  },
+  .ctorInfo {
+      name := n ++ `mk
+      levelParams := []
+      -- Should be `Lean.mkConst n`; returning `Nat` is the defect.
+      type := Lean.mkConst ``Nat
+      numParams := 0
+      induct := n
+      cidx := 0
+      numFields := 0
+      isUnsafe := false
+  },
+  dummyRecInfo n
+  ]
+
+-- A projection of field 0 taken on a TWO-constructor inductive, applied
+-- to a value built by the other ctor. `k_infer_proj` ignored
+-- `num_ctors` and unconditionally read ctor 0's field types, so this
+-- inferred `Empty` from an `@Sum.inr Empty Unit ()`.
+bad_raw_consts
+  #[ .defnInfo {
+      name := `r4ProjMultiCtorBad
+      levelParams := []
+      type := Lean.mkConst ``Empty
+      value :=
+        -- `Sum.{u,v}` is universe-polymorphic in both arguments; omitting
+        -- the levels makes the kernel reject on level-count mismatch
+        -- before it ever reaches the projection.
+        .proj ``Sum 0 <|
+          Lean.mkApp3 (Lean.mkConst ``Sum.inr [0, 0])
+            (Lean.mkConst ``Empty) (Lean.mkConst ``Unit)
+            (Lean.mkConst ``Unit.unit)
+      hints := .abbrev
+      safety := .safe
+  }]
+
+/-- Single constructor, no indices, and RECURSIVE — passes the shape
+    half of the structure-eta gate but is not `isStructureLike`, so eta
+    must not fire on it. Uninhabited, which is irrelevant: the fixture
+    compares open terms under a binder. -/
+inductive EtaRecStruct where
+  | node : EtaRecStruct → EtaRecStruct
+
+-- `Eq.refl x : x = x` checked against `x = EtaRecStruct.node x.0`. The
+-- only way to accept it is structure eta, which `try_eta_struct` used to
+-- allow here because it tested only (0 indices, 1 ctor) and dropped the
+-- non-recursive requirement.
+bad_raw_consts
+  #[ .thmInfo {
+      name := `r5EtaRecursiveBad
+      levelParams := []
+      type :=
+        Lean.mkForall `x .default (Lean.mkConst ``EtaRecStruct) <|
+          Lean.mkApp3 (Lean.mkConst ``Eq [1]) (Lean.mkConst ``EtaRecStruct)
+            (.bvar 0)
+            (Lean.mkApp (Lean.mkConst ``EtaRecStruct.node)
+              (.proj ``EtaRecStruct 0 (.bvar 0)))
+      value :=
+        Lean.mkLambda `x .default (Lean.mkConst ``EtaRecStruct) <|
+          Lean.mkApp2 (Lean.mkConst ``Eq.refl [1])
+            (Lean.mkConst ``EtaRecStruct) (.bvar 0)
+  }]
+
+-- R6: strict positivity must descend into a NESTED inductive's own
+-- constructors.
+--
+-- Shape matters here. `check_positivity_aug` short-circuits on
+-- `expr_mentions_block(dom, block_addrs) == 0`, so the descent only
+-- fires when the host appears INSIDE the nested inductive's arguments.
+-- `r6Host`'s field is `r6NegBox r6Host`, which mentions the host block
+-- and so gets past the early-out; the head `r6NegBox` is not a peer, its
+-- post-param args are empty (so the existing index check passes), and
+-- before the augmenting descent the walk simply returned there.
+--
+-- `r6NegBox` is not strictly positive in its OWN block — its field is
+-- `(r6NegBox α → Empty)`, a negative self-occurrence. Only by descending
+-- into its constructors under an augmented block set is that visible
+-- while checking `r6Host`. Both names must be rejected: `r6NegBox` on
+-- its own merits, `r6Host` only via the descent.
+bad_raw_consts
+  let neg := `r6NegBox
+  let host := `r6Host
+  #[ .inductInfo {
+      name := neg
+      levelParams := []
+      -- r6NegBox : Type → Type
+      type := arrow (.sort 1) (.sort 1)
+      numParams := 1
+      numIndices := 0
+      all := [neg]
+      ctors := [neg ++ `mk]
+      numNested := 0
+      isRec := true
+      isUnsafe := false
+      isReflexive := true
+  },
+  .ctorInfo {
+      name := neg ++ `mk
+      levelParams := []
+      -- ∀ (α : Type), ((r6NegBox α → Empty)) → r6NegBox α
+      -- α is bvar 0 inside the field domain, bvar 1 in the return type
+      -- (one extra binder from the field itself).
+      type :=
+        Lean.mkForall `α .default (.sort 1) <|
+          Lean.mkForall `f .default
+            (Lean.mkForall `x .default
+              (Lean.mkApp (Lean.mkConst neg) (.bvar 0))
+              (Lean.mkConst ``Empty))
+            (Lean.mkApp (Lean.mkConst neg) (.bvar 1))
+      numParams := 1
+      induct := neg
+      cidx := 0
+      numFields := 1
+      isUnsafe := false
+  },
+  dummyRecInfo neg,
+  .inductInfo {
+      name := host
+      levelParams := []
+      type := .sort 1
+      numParams := 0
+      numIndices := 0
+      all := [host]
+      ctors := [host ++ `mk]
+      -- Honest flags: the compile-side `validate_ind_flags` recomputes
+      -- these and rejects the whole env on a mismatch, which would
+      -- poison every other fixture. `r6Host` nests one inductive and is
+      -- reflexive through it.
+      numNested := 1
+      isRec := true
+      isUnsafe := false
+      isReflexive := true
+  },
+  .ctorInfo {
+      name := host ++ `mk
+      levelParams := []
+      -- r6NegBox r6Host → r6Host : mentions the host block, so the walk
+      -- reaches the nested inductive instead of short-circuiting.
+      type :=
+        arrow (Lean.mkApp (Lean.mkConst neg) (Lean.mkConst host))
+              (Lean.mkConst host)
+      numParams := 0
+      induct := host
+      cidx := 0
+      numFields := 1
+      isUnsafe := false
+  },
+  dummyRecInfo host
+  ]
+
+/-! ### R8: recursive field behind a reducible definition
+
+`is_rec_field` decides whether a constructor field gets an induction
+hypothesis in the reconstructed recursor rule. It peels Foralls and takes
+the spine, but does not reduce — so a field whose recursive occurrence
+sits behind a reducible definition is classified NOT recursive, the
+reconstruction omits the IH, and `compare_rules` then disagrees with the
+real recursor (which has it).
+
+`R8Box` is an `abbrev`, so the field elaborates to `R8Box R8B` with the
+constant intact (verified: Lean stores `(R8Box R8B) -> R8A`); only WHNF
+exposes the `R8B` head underneath.
+
+The block must be MUTUAL. For a solo inductive `check_recursor_canonical_full`
+bails before reaching `is_rec_field` — `build_flat_block` returns `Nil`
+when the recursor's block is not a Muts block — so a solo fixture passes
+regardless of the defect. That bail is R3.
+
+GOOD fixture: Lean accepts these declarations, so the kernel must too.
+Fails until the reduction is restored. -/
+
+abbrev R8Box (α : Type) : Type := α
+
+mutual
+  inductive R8A where
+    | mk : R8Box R8B → R8A
+  inductive R8B where
+    | mk : R8A → R8B
+end
+
+good_consts #[``R8A, ``R8B, ``R8A.rec, ``R8B.rec]
+
 end Tests.Ix.Kernel.TutorialDefs
diff --git a/Tests/Main.lean b/Tests/Main.lean
index dbc93934e..4f93784a7 100644
--- a/Tests/Main.lean
+++ b/Tests/Main.lean
@@ -4,6 +4,7 @@ import Tests.Ix.Ixon
 import Tests.Ix.IxonCorpus
 import Tests.Ix.IxonSyntax
 import Tests.Ix.IxVM
+import Tests.Ix.IxVM.Exploits
 import Tests.Ix.Claim
 import Tests.Ix.Merkle
 import Tests.Ix.AssumptionTree
@@ -25,6 +26,7 @@ import Tests.Ix.Kernel.Roundtrip
 import Tests.Ix.Kernel.RoundtripNoCompile
 import Tests.Ix.Kernel.Tutorial
 import Tests.Ix.Kernel.Arena
+import Tests.Ix.Kernel.PrimAddrs
 import Tests.Ix.RustSerialize
 import Tests.Ix.RustDecompile
 import Tests.Ix.Sharing
@@ -79,6 +81,7 @@ def primarySuites : Std.HashMap String (List LSpec.TestSeq) := .ofList [
   ("aux-gen-unit", Tests.AuxGen.ExprUtils.suite ++ Tests.AuxGen.Levels.suite ++ Tests.AuxGen.Recursor.suite ++ Tests.AuxGen.Surgery.suite),
   ("ground-unit", Tests.Ground.suite),
   ("aiur-cross", [AiurTests.Cross.tests]),
+  ("prim-addrs", Tests.Ix.Kernel.PrimAddrs.suite),
   ("tc-unit", Tests.Tc.Unit.suite ++ Tests.Tc.Substrate.suite
     ++ Tests.Tc.Fixtures.suite ++ Tests.Tc.WhnfTests.suite
     ++ Tests.Tc.InferDefEq.suite ++ Tests.Tc.CheckTests.suite
@@ -133,26 +136,74 @@ def ignoredRunners (env : Lean.Environment) : List (String × IO UInt32) := [
     let r2 ← LSpec.lspecEachIO sha256TestCases fun tc => pure (sha256Env.runTestCase tc)
     return if r1 == 0 && r2 == 0 then 0 else 1),
   ("ixvm", do
-    let kernelUnitTests := .exec `kernel_unit_tests
-    let serdeNatAddCommTest ← serdeNatAddComm env
     let kernelChecks ← kernelChecks env
-    let claimSmokes ← claimSmokeTests env
+    -- the kernel CheckEnv smokes .
+    let claimEnv ← IxVM.ClaimHarness.loadIxonEnv ``Nat.add_comm env
+    let envFull ← claimCheckEnvFull claimEnv
+    let envFrontier ← claimCheckEnvFrontier claimEnv
+    let checkAsm ← claimCheckWithAsm claimEnv
+    let revealFields ← claimRevealDefnFields claimEnv
+    let revealExpr ← claimRevealDefnExpr claimEnv
+    let revealCPrj ← claimRevealCPrj claimEnv
+    let containsTc ← claimContains
+    -- Codegen parity gate: the generated Rust kernel is emitted from the
+    -- toplevel, so this runs the same witnesses through both engines and
+    -- asserts they agree. It is only meaningful against a CURRENT
+    -- `ix codegen` output — regenerate after any Aiur edit, or this gate
+    -- compares against a stale kernel.
     let parityCases ← parityCases env
-    -- Test-only entrypoints (`kernel_unit_tests`, `ixon_serde_test`) exist
-    -- only in the FULL toplevel; everything codegen-coupled (kernel checks,
-    -- claim smokes, arena, parity) runs on the pruned production toplevel —
-    -- the one `ix codegen` mirrors.
+    -- Shared-infrastructure test entrypoints live only in the FULL
+    -- toplevel (pruning drops them so test-only circuits never widen a
+    -- committed kernel system).
+    let kernelUnitTests := .exec `kernel_unit_tests
+    let serdeTest ← serdeNatAddComm env
     match AiurTestEnv.build IxVM.ixVM, AiurTestEnv.build IxVM.ixVMFull with
-    | .error e, _ | _, .error e => IO.eprintln s!"IxVM env build failed: {e}"; return 1
-    | .ok aiurEnv, .ok fullEnv =>
-      let arenaSeq ← Tests.Ix.Kernel.Arena.arenaTests env aiurEnv.compiled
-      let fullSeq := [kernelUnitTests, serdeNatAddCommTest].foldl (init := .done)
-        fun s tc => s ++ fullEnv.runTestCase tc
-      let aiurSeq := (kernelChecks ++ claimSmokes).foldl (init := .done) fun s tc =>
-        s ++ aiurEnv.runTestCase tc
+    | .error e, _ | _, .error e =>
+      IO.eprintln s!"IxVM env build failed: {e}"; return 1
+    | .ok v2Env, .ok v2FullEnv =>
+      -- Kernel-arena fixtures: the repo's NEGATIVE corpus (every
+      -- `bad_*` must be rejected by an in-kernel assert_eq!). Runs
+      -- through the kernel's subject-only `verify_const` debug
+      -- entrypoint, which lives only in the FULL toplevel — the
+      -- production one carries `verify_claim` alone.
+      let arenaSeq ← Tests.Ix.Kernel.Arena.arenaTests env v2FullEnv.compiled
+      -- Adversarial Ixon: exploit attempts authored as raw Ixon
+      -- constants, below the layer the arena's Lean fixtures can
+      -- reach. Each case pins the kernel's verdict, which is REJECT
+      -- except where accepting is the specified claim semantics.
+      let exploitSeq ← Tests.Ix.IxVM.Exploits.exploitTests env v2Env.compiled
+      let aiurSeq := (kernelChecks ++
+          [envFull, envFrontier, checkAsm,
+           revealFields, revealExpr, revealCPrj, containsTc]).foldl
+        (init := .done) fun s tc => s ++ v2Env.runTestCase tc
       let paritySeq := parityCases.foldl (init := .done) fun s tc =>
-        s ++ runParityCase aiurEnv.compiled tc
-      LSpec.lspecIO (.ofList [("ixvm", [fullSeq, aiurSeq, arenaSeq, paritySeq])]) []),
+        s ++ runParityCase v2Env.compiled tc
+      let fullSeq := [kernelUnitTests, serdeTest].foldl (init := .done)
+        fun s tc => s ++ v2FullEnv.runTestCase tc
+      -- Shard pipeline: witness built in Rust (thin-frontier claim,
+      -- parallel closure walk) and run on the native kernel. Pinned FFT
+      -- is the regression signal.
+      let shardSeq ← match (← shardCheckEnvCase env) with
+        -- Only reachable when the target constant is absent from this
+        -- toolchain; a fixture that no longer selects any owned
+        -- constants throws instead of skipping.
+        | none => pure (LSpec.test "shard pipeline: SKIP (target absent)" true)
+        | some (handle, ownedBlob) =>
+          let funIdx := v2Env.compiled.getFuncIdx `verify_claim |>.get!
+          match v2Env.compiled.bytecode.shardCheckWithEnv
+                  funIdx handle ownedBlob false with
+          | .error e =>
+            pure (LSpec.test s!"shard pipeline execution: {e}" false)
+          | .ok (_, _, qc) =>
+            -- Exact pin, same convention as `kernelCheckEntries`
+            -- (`.round.toUInt64.toNat`): any cost shift must be an
+            -- explicit, reviewed bump.
+            let cost :=
+              (Aiur.computeStats v2Env.compiled qc).totalFftCost.round.toUInt64.toNat
+            pure (LSpec.test "shard pipeline FFT" (cost == 1_950_063_326))
+      LSpec.lspecIO
+        (.ofList [("ixvm",
+          [fullSeq, aiurSeq, arenaSeq, exploitSeq, paritySeq, shardSeq])]) []),
   ("rbtree-map", do
     IO.println "rbtree-map"
     match AiurTestEnv.build (pure IxVM.rbTreeMap) with
@@ -215,6 +266,15 @@ def main (args : List String) : IO UInt32 := do
     let mut result ← LSpec.lspecIO ignoredSuites filterArgs
     let env ← get_env!
     let ignored := ignoredRunners env
+    -- A filter arg matching no runner must be an ERROR, not a silent
+    -- no-op: `filterMap` would drop it, leaving nothing to run and
+    -- returning 0, so a typo'd suite name reports success having
+    -- executed nothing.
+    for arg in filterArgs do
+      if !(ignored.any fun (key, _) => key == arg)
+          && !ignoredSuites.contains arg then
+        IO.eprintln s!"error: no ignored suite or runner named '{arg}'"
+        return 1
     let filtered := if filterArgs.isEmpty then ignored
       else filterArgs.filterMap fun arg => ignored.find? fun (key, _) => key == arg
     for (_, action) in filtered do
diff --git a/crates/aiur/src/bytecode.rs b/crates/aiur/src/bytecode.rs
index 7da57a2a5..65677e590 100644
--- a/crates/aiur/src/bytecode.rs
+++ b/crates/aiur/src/bytecode.rs
@@ -42,7 +42,7 @@ pub enum Op {
   Call(FunIdx, Vec<ValIdx>, usize, bool),
   Store(Vec<ValIdx>),
   Load(usize, ValIdx),
-  AssertEq(Vec<ValIdx>, Vec<ValIdx>),
+  AssertEq(Vec<ValIdx>, Vec<ValIdx>, Option<String>),
   IOGetInfo(ValIdx, Vec<ValIdx>),
   IOSetInfo(ValIdx, Vec<ValIdx>, ValIdx, ValIdx),
   IORead(ValIdx, ValIdx, usize),
diff --git a/crates/aiur/src/constraints.rs b/crates/aiur/src/constraints.rs
index 018279293..f9383956f 100644
--- a/crates/aiur/src/constraints.rs
+++ b/crates/aiur/src/constraints.rs
@@ -438,7 +438,10 @@ impl Op {
         combine_lookup_args(lookup, lookup_args);
         lookup.multiplicity = lookup.multiplicity.clone() + sel.clone();
       },
-      Op::AssertEq(xs, ys) => {
+      // The message is diagnostic only — it never enters the constraint
+      // system, so a labelled and an unlabelled assert are identical in
+      // the circuit.
+      Op::AssertEq(xs, ys, _) => {
         assert_eq!(xs.len(), ys.len());
         for (x, y) in xs.iter().zip(ys) {
           let (x, _) = &state.map[*x];
diff --git a/crates/aiur/src/execute.rs b/crates/aiur/src/execute.rs
index 389dfb5b4..69e03e12c 100644
--- a/crates/aiur/src/execute.rs
+++ b/crates/aiur/src/execute.rs
@@ -115,6 +115,10 @@ pub enum ExecError {
   AssertEqMismatch {
     lhs: u64,
     rhs: u64,
+    /// Optional label from `assert_eq!(a, b, "…")`, surfaced in the error
+    /// so a failing assert identifies itself instead of reporting bare
+    /// operands that could have come from anywhere.
+    msg: Option<String>,
   },
   MatchNoCase(u64),
   NoContinuation,
@@ -152,8 +156,9 @@ impl std::fmt::Display for ExecError {
       Self::AssertEqLengthMismatch { lhs, rhs } => {
         write!(f, "assert_eq length mismatch: lhs={lhs}, rhs={rhs}")
       },
-      Self::AssertEqMismatch { lhs, rhs } => {
-        write!(f, "assert_eq mismatch: {lhs} != {rhs}")
+      Self::AssertEqMismatch { lhs, rhs, msg } => match msg {
+        Some(m) => write!(f, "assert_eq mismatch: {lhs} != {rhs} ({m})"),
+        None => write!(f, "assert_eq mismatch: {lhs} != {rhs}"),
       },
       Self::MatchNoCase(v) => write!(f, "no match case for value {v}"),
       Self::NoContinuation => write!(f, "yield without continuation"),
@@ -255,7 +260,7 @@ impl Function {
     io_buffer: &mut IOBuffer,
   ) -> Result<Vec<G>, ExecError> {
     let mut exec_entries_stack = vec![];
-    let mut callers_states_stack = vec![];
+    let mut callers_states_stack: Vec<CallerState> = vec![];
     let mut continuation_stack: Vec<ContinuationState<'_>> = vec![];
     macro_rules! push_block_exec_entries {
       ($block:expr) => {
@@ -271,6 +276,17 @@ impl Function {
         stats_ops += 1;
         if stats_ops.is_multiple_of(1 << 31) {
           dump_query_stats(record, &format!("ops={stats_ops}"));
+          let depth = callers_states_stack.len();
+          let tail: Vec<String> = callers_states_stack
+            .iter()
+            .rev()
+            .take(40)
+            .map(|cs| cs.fun_idx.to_string())
+            .collect();
+          eprintln!(
+            "[aiur-stats] call stack depth={depth}, top fns: {}",
+            tail.join(" ")
+          );
         }
       }
       match exec_entry {
@@ -356,7 +372,7 @@ impl Function {
           }
           map.extend_from_slice(args);
         },
-        ExecEntry::Op(Op::AssertEq(xs, ys)) => {
+        ExecEntry::Op(Op::AssertEq(xs, ys, msg)) => {
           if xs.len() != ys.len() {
             return Err(ExecError::AssertEqLengthMismatch {
               lhs: xs.len(),
@@ -370,6 +386,7 @@ impl Function {
               return Err(ExecError::AssertEqMismatch {
                 lhs: lhs.as_canonical_u64(),
                 rhs: rhs.as_canonical_u64(),
+                msg: msg.clone(),
               });
             }
           }
diff --git a/crates/common/src/lib.rs b/crates/common/src/lib.rs
index e51d043cf..819a33712 100644
--- a/crates/common/src/lib.rs
+++ b/crates/common/src/lib.rs
@@ -15,6 +15,7 @@ use rustc_hash::FxBuildHasher;
 
 pub mod address;
 pub mod env;
+pub mod prim_addrs;
 pub mod strong_ordering;
 
 pub type FxIndexMap<K, V> = IndexMap<K, V, FxBuildHasher>;
diff --git a/crates/common/src/prim_addrs.rs b/crates/common/src/prim_addrs.rs
new file mode 100644
index 000000000..c4ddf7c2a
--- /dev/null
+++ b/crates/common/src/prim_addrs.rs
@@ -0,0 +1,864 @@
+//! Hardcoded primitive content-addresses.
+//!
+//! Lives in `ix-common` rather than `ix-kernel` because several crates
+//! need this table and `ixon` (and everything above it) cannot depend on
+//! the kernel — `ix-kernel` already depends on `ixon`, so the edge would
+//! be a cycle. Witness builders need it to seed primitives the kernel
+//! FABRICATES during reduction rather than discovers by walking `refs`.
+//!
+//! Addresses are blake3 hashes of each primitive's Ixon-compiled form.
+//! Regenerate with `lake test -- rust-kernel-build-primitives`, which
+//! dumps the current `(name, hex)` pairs — paste the updated lines into
+//! `PrimAddrs::new`. `lake test -- prim-addrs` pins this table against
+//! the Lean mirror in `Ix/Tc/Primitive.lean`.
+
+use std::sync::LazyLock;
+
+use crate::address::Address;
+
+/// Hardcoded primitive addresses (for lookup in the env).
+pub struct PrimAddrs {
+  pub nat: Address,
+  pub nat_zero: Address,
+  pub nat_succ: Address,
+  pub nat_add: Address,
+  pub nat_pred: Address,
+  pub nat_sub: Address,
+  pub nat_mul: Address,
+  pub nat_pow: Address,
+  pub nat_gcd: Address,
+  pub nat_mod: Address,
+  pub nat_div: Address,
+  pub nat_bitwise: Address,
+  pub nat_beq: Address,
+  pub nat_ble: Address,
+  pub nat_land: Address,
+  pub nat_lor: Address,
+  pub nat_xor: Address,
+  pub nat_shift_left: Address,
+  pub nat_shift_right: Address,
+  pub bool_type: Address,
+  pub bool_true: Address,
+  pub bool_false: Address,
+  pub string: Address,
+  pub string_mk: Address,
+  pub char_type: Address,
+  pub char_mk: Address,
+  pub char_of_nat: Address,
+  pub string_of_list: Address,
+  pub string_to_byte_array: Address,
+  pub byte_array_empty: Address,
+  pub list: Address,
+  pub list_nil: Address,
+  pub list_cons: Address,
+  pub eq: Address,
+  pub eq_refl: Address,
+  pub quot_type: Address,
+  pub quot_ctor: Address,
+  pub quot_lift: Address,
+  pub quot_ind: Address,
+  pub reduce_bool: Address,
+  pub reduce_nat: Address,
+  pub eager_reduce: Address,
+  pub system_platform_num_bits: Address,
+  pub system_platform_get_num_bits: Address,
+  pub subtype_val: Address,
+  pub nat_dec_le: Address,
+  pub nat_dec_eq: Address,
+  pub nat_dec_lt: Address,
+  pub decidable_rec: Address,
+  pub decidable_is_true: Address,
+  pub decidable_is_false: Address,
+  pub nat_le_of_ble_eq_true: Address,
+  pub nat_not_le_of_not_ble_eq_true: Address,
+  pub nat_eq_of_beq_eq_true: Address,
+  pub nat_ne_of_beq_eq_false: Address,
+  pub fin: Address,
+  pub bool_no_confusion: Address,
+  // Int addresses — see `Primitives` for why these exist.
+  pub int: Address,
+  pub int_of_nat: Address,
+  pub int_neg_succ: Address,
+  pub int_add: Address,
+  pub int_sub: Address,
+  pub int_mul: Address,
+  pub int_neg: Address,
+  pub int_emod: Address,
+  pub int_ediv: Address,
+  pub int_bmod: Address,
+  pub int_bdiv: Address,
+  pub int_nat_abs: Address,
+  pub int_pow: Address,
+  pub int_dec_eq: Address,
+  pub int_dec_le: Address,
+  pub int_dec_lt: Address,
+  pub punit: Address,
+  pub pprod: Address,
+  pub pprod_mk: Address,
+
+  // See `Primitives<M>` for the rationale on these — names previously
+  // matched via name-based `is_const_named` and now resolved by address.
+  pub nat_rec: Address,
+  pub nat_cases_on: Address,
+  pub bit_vec: Address,
+  pub bit_vec_to_nat: Address,
+  pub bit_vec_of_nat: Address,
+  pub bit_vec_ult: Address,
+  pub decidable_decide: Address,
+  pub lt_lt: Address,
+  pub of_nat_of_nat: Address,
+  pub unit: Address,
+  pub punit_size_of_1: Address,
+  pub size_of_size_of: Address,
+  pub string_back: Address,
+  pub string_legacy_back: Address,
+  pub string_utf8_byte_size: Address,
+  pub string_append: Address,
+  pub string_dec_eq: Address,
+}
+
+impl Default for PrimAddrs {
+  fn default() -> Self {
+    Self::new()
+  }
+}
+
+impl PrimAddrs {
+  /// Addresses reserved for kernel-only reduction markers. These are not
+  /// Lean constants and must never be accepted as user environment entries.
+  pub fn reserved_marker_addrs() -> [(&'static str, Address); 2] {
+    let canon = Self::new();
+    let orig = Self::new_orig();
+    [
+      ("eager_reduce", canon.eager_reduce.clone()),
+      ("orig.eager_reduce", orig.eager_reduce.clone()),
+    ]
+  }
+
+  /// Canonical content-hash addresses, hardcoded from the Ixon-compiled
+  /// form of each primitive. Used by `Primitives::from_env` to resolve
+  /// primitives against a `kctx.kenv` whose KIds live at canonical
+  /// addresses. Regenerate with `lake test -- rust-kernel-build-primitives`.
+  pub fn new() -> Self {
+    let h = |hex: &str| -> Address {
+      Address::from_hex(hex).expect("invalid primitive address hex")
+    };
+    PrimAddrs {
+      nat: h(
+        "398a7706cf13f223992d173dce07946857240f49afcc743723e839f8f3f2b631",
+      ),
+      nat_zero: h(
+        "d397370157fb9ae2c6e1eda79feb10bf497401741aba788fab726cfa4c467db6",
+      ),
+      nat_succ: h(
+        "def52d1dad5f10cf9893c945e169718d62b15e2dd2c9066e597b9d4570ba056e",
+      ),
+      nat_add: h(
+        "d6f62a9779108f9fb6b66b31cc94c3d84ca72d8bea185e13137c50c7ef84c969",
+      ),
+      nat_pred: h(
+        "914f9c01884853652e9224dc511f867d5408517f3beb3192fc4477e0e9594c88",
+      ),
+      nat_sub: h(
+        "fdbd5fef40149c85333c6f3ccebb4be741270d2066336cb2eef87623744b72b0",
+      ),
+      nat_mul: h(
+        "6649665607b0750c2ca73f45de600f21cb670398504865bb97972438014f96d9",
+      ),
+      nat_pow: h(
+        "33c604451d01cb19a433668246b98f6e874bd630b78a791d7a373a979849a1cf",
+      ),
+      nat_gcd: h(
+        "3be48357ae17f74d4df27d697aed3f47c1307941f41affcf74da5f66d511a797",
+      ),
+      nat_mod: h(
+        "5179638b82cc8337914a7bcaad858c85888844e9a292430cac51e5eadc41a1af",
+      ),
+      nat_div: h(
+        "89deca86dd8f0066a5064fdb19a2c6897a3a9867caadc04f778d5c5cd0225362",
+      ),
+      nat_bitwise: h(
+        "d2075e323bed82f23eaf75ebc0fae4ceb80794240c046b90c51a94d07f5e885f",
+      ),
+      nat_beq: h(
+        "a34ab2daba34839e851fa3675124566f9f4dcde597349ecd54ae32f8424e44b8",
+      ),
+      nat_ble: h(
+        "de0befa84faa22d1394379a0ba67296e116660f781b4eb639dbbaba200ef2bf8",
+      ),
+      nat_land: h(
+        "818abb331150400d10b34fae4dfb9426741c4607baeed8d96271ba1659058ef8",
+      ),
+      nat_lor: h(
+        "9b76f32bbb1dbdf4ff68e0221225015df0ca2d2a6023c1a81306d4020d4ef397",
+      ),
+      nat_xor: h(
+        "97e325a96a6a1827194eeb7d2aa0d91921073aef9c2d333c24613e9ac956ed29",
+      ),
+      nat_shift_left: h(
+        "dc81e41cad1190377dbe604bfc3afe658a413b9a2dcfbcab79fad7b7a5cdd954",
+      ),
+      nat_shift_right: h(
+        "6db49304bf0f5acbfd1d9d9a0c1b7ae20ef99d0737887056129f5b5cb5a9ba8a",
+      ),
+      bool_type: h(
+        "e6eba3c8b4d19f6a1076b39fa89aec61dccbb960f83d9a62e6acf35a69c9a0a4",
+      ),
+      bool_true: h(
+        "a29a636176cf1135d077eb074798f9007c78e7801383e9cff363bae5edf05762",
+      ),
+      bool_false: h(
+        "dda12bcb330727f6dfb816bc9752aabd0520e6515b79fc8a5a9e713866f4c63e",
+      ),
+      string: h(
+        "7ab2d52ac52fd1f51809b718e53cd058ac4b50d65150e78ae619139ccf13c8fd",
+      ),
+      string_mk: h(
+        "9671fd4fcfbc061c93c2824864cf03124ffee7cc22308de12a7c826473e49906",
+      ),
+      char_type: h(
+        "29dd2d1986a525bdde49b4ad2defc349cec71d0484cd13f2da92f1fce89a4c79",
+      ),
+      char_mk: h(
+        "97afa5ad3d86895e6d155019b66c256cd1aa862b4e3c89d8c6580b61939ee541",
+      ),
+      char_of_nat: h(
+        "1a4c66f76760f5ef386de089682a55b752131e14a08557c4465ed17fe0c4dc86",
+      ),
+      // NOTE: `String.ofList` and `String.mk` share the canonical content-hash
+      // because both compile to the same Ixon form (a one-constructor `String`
+      // built from `List Char`). The Lean-side deprecation of `String.mk` in
+      // favor of `String.ofList` is orthogonal to the compiled representation.
+      string_of_list: h(
+        "9671fd4fcfbc061c93c2824864cf03124ffee7cc22308de12a7c826473e49906",
+      ),
+      string_to_byte_array: h(
+        "ed43c77e555593b6cd0d4bfbc4273ba122e1c0cdf1090571612a952f941eadb1",
+      ),
+      byte_array_empty: h(
+        "7cfba8fa95847c213aa4066110ba01a97fb597daf29f5c07f72366072f250744",
+      ),
+      list: h(
+        "144e207a88d1dfbde22a1b40689033b3a65a652c8f7500b9be3cb7f66366e0fe",
+      ),
+      list_nil: h(
+        "258a7364b87c99fe9f83e05e0d05c935609a0dc5df8d77939130efe5e0efca3e",
+      ),
+      list_cons: h(
+        "77d519259ec9fa489dbe0e3dc0b9352aef349ccdaa73ea58b08bb0bc683502a0",
+      ),
+      eq: h("036b63d5cc0961e920dee50e7364ec0dd3f9c38a9cace40e513b3835dec8e0c9"),
+      eq_refl: h(
+        "6c9bd60e1eae938e5626ca237dbca7fd950f2e99e234a99c23cfdc294ca7adce",
+      ),
+      quot_type: h(
+        "ab682c1778a17bbeae4032974df36447ce8bfcab6764a36d378566e3ad63cab8",
+      ),
+      quot_ctor: h(
+        "88266677fee774d109867e4b2240281aa2ee12d97920c1171cf5c1f6c87decf6",
+      ),
+      quot_lift: h(
+        "8dc4a97527812f8b7817b77cd079ace61450aa0185ac5885661ec2acba8b7bd0",
+      ),
+      quot_ind: h(
+        "124984bcb95208a0f30bb69d6736d3d59404e115e2202043fda3d34e01b0ad16",
+      ),
+      reduce_bool: h(
+        "1c170098e23143fd8fd6172cefd2ecee305072d2991113cfc4d52840a5a9fa78",
+      ),
+      reduce_nat: h(
+        "16853076b0d96d356d85485c56f3398014b6a0f2ee72ab16284a381d9c28e560",
+      ),
+      // Synthetic kernel-only marker. This is intentionally not the compiled
+      // Lean content hash: `eagerReduce` canonicalizes to the same content
+      // address as the real Lean constant `id`, so address-only dispatch would
+      // give ordinary `id` terms special reduction semantics.
+      eager_reduce: h(
+        "ff00000000000000000000000000000000000000000000000000000000000003",
+      ),
+      system_platform_num_bits: h(
+        "cf86263521d345c39076473ecdb9f6fd411b5b503bce83e2318ba3fb6f2376d8",
+      ),
+      system_platform_get_num_bits: h(
+        "f5d256c1dd794d02cfdf1762c9e41b13abe5bddde12d929d02ada37e4f40e85f",
+      ),
+      subtype_val: h(
+        "0b5958a3c822c99e8643a27f0b928dfb82c45447bee0353c200ad1b7d0e46092",
+      ),
+      nat_dec_le: h(
+        "ec1f60c1a28d48bc98fe3ef72d255132735a503cc36e3ff0f22e3d486e266ebe",
+      ),
+      nat_dec_eq: h(
+        "b4b26c2e29931c06e885914613faff5856138e5cb09620ddb6921a342ded8957",
+      ),
+      nat_dec_lt: h(
+        "c013c153ebf02028aed264333c1e4c85017d0b87025d7596a96971bb2b67921d",
+      ),
+      decidable_rec: h(
+        "ab3776985743af13a9cb1a7d2f8496997892e17983d14be5270a716570b35719",
+      ),
+      decidable_is_true: h(
+        "0f9ee8d9033d8f7b852f5b7152fd124f7d411930c992e0f457f8104b60a98381",
+      ),
+      decidable_is_false: h(
+        "0471e47158b2ae18d3c08dd5c77aae23e62d7bbc1e61116bc2813b1306bc5795",
+      ),
+      nat_le_of_ble_eq_true: h(
+        "21e0e0783b7617b0cc4eff4d1fab7cffefe01cd43da77e2f98d15094a0d8f086",
+      ),
+      nat_not_le_of_not_ble_eq_true: h(
+        "0183595b837b9b84da5f004b8ac4a4bbd3bc0628b99c8d550eb351f74ce16d48",
+      ),
+      nat_eq_of_beq_eq_true: h(
+        "9ce6e322f19481f21cf4c48f88789876b69b8a9b1520439c101d983f96ea60b7",
+      ),
+      nat_ne_of_beq_eq_false: h(
+        "3cf54d333821dd37683a0bf38739e687610a1991759220b77edec338ba3cfbc8",
+      ),
+      fin: h(
+        "745936fcb9d86c4457f0fd1e537e67077f46f7841108419dac7984008b565b97",
+      ),
+      bool_no_confusion: h(
+        "cd983a826c1e20c4570afca244916c79e20e816f618ffdda38be8a79079274ce",
+      ),
+      // Int primitives — canonical content-hashes from
+      // `lake test -- rust-kernel-build-primitives`.
+      int: h(
+        "a5ca2e1d5ceb8d43367bc34d69a50c1650a25dc10780aa0c378cdfa931ff0424",
+      ),
+      int_of_nat: h(
+        "09bc253147c36ce22c8e0ccd43c79b2cdae2206e0ddd168fca3609b2a584d3dc",
+      ),
+      int_neg_succ: h(
+        "267c0a9c92e75638fc73ed52a9f9c81647eeeceeff2144c1f97e65e2aff149f1",
+      ),
+      int_add: h(
+        "ca99084c9d2fcb4c5dd139aecaf159ebd04992d76230cb930f41b86074684817",
+      ),
+      int_sub: h(
+        "d3141231800e012e8db7c240f794e4929bfd156b3845e22f1cf31d3fe39aecd9",
+      ),
+      int_mul: h(
+        "482064e35634a95c0f252de73d687c24764ea4fa7dfd14cf7af8aa7531f17a5c",
+      ),
+      int_neg: h(
+        "f61c7d3fce595430f86f0cd52da5bcb00bf910edd85e14dc0402130fcce34ebd",
+      ),
+      int_emod: h(
+        "25c267ef44f15007f2d2e0819be6fb64902c33a7d27a6f2c9d61263898953804",
+      ),
+      int_ediv: h(
+        "49b34dcbff1e60532825ff5af477eb5de9810ee38e0f7a32014d54c8c1a3a3c5",
+      ),
+      int_bmod: h(
+        "6a6adf0e95b3a4ce18330ee22105712e9a640ee4311b5dd1022a8e0a30cba0af",
+      ),
+      int_bdiv: h(
+        "a4f1d7a3fe5b6b2ef9522fa537f1e622fbb8176f9fb3358c56cebe1a379b6184",
+      ),
+      int_nat_abs: h(
+        "83e3ce8a747520cc248a0dacf9bd1369467e4907e8aaaa433e1b438e1cad7ca4",
+      ),
+      int_pow: h(
+        "73ecccfeab8a63a3a0faf8d71dc77995bda83418b13cd399b1fa571b50b4575e",
+      ),
+      int_dec_eq: h(
+        "83fde38faa1164648e4227975abf2e8c260d7d4ef1c92676214ffe5826c2075d",
+      ),
+      int_dec_le: h(
+        "38d60ffa07b50678d0c3bf0c06f86cd7967b35e87ab071bc55899fcbaed4744f",
+      ),
+      int_dec_lt: h(
+        "5568e799198dad9fab0e784b7a4c58112bfc2688aecebe3c2c6563304210f956",
+      ),
+      punit: h(
+        "2dfc16af01b82b3b91c2ff704409d76236a83f956c0c6e6659a64fe21d76695b",
+      ),
+      pprod: h(
+        "81a422a42b2cb656b9a47e61a4422f89cdb0a0c166035d47bf5e2c2af02175fa",
+      ),
+      pprod_mk: h(
+        "c9c584da782cdc453306be9a643244fa0bcbfc3b5dbcbafe3f6b9d65df031fed",
+      ),
+      // Names previously matched via `is_const_named` in whnf.rs.
+      // Canonical content-hashes from `lake test -- rust-kernel-build-primitives`.
+      nat_rec: h(
+        "b975152f3f0cd9039433c68f5a5e5455f5cb5d917078baed0118b59067a74ea7",
+      ),
+      nat_cases_on: h(
+        "1917841d2085796dd7ba346de93a579571b5641c33fc400408ec55b5778a9a51",
+      ),
+      bit_vec: h(
+        "698dd593abfb63db362aaef57e70a793044fb657257291ee2c3e997caa423eae",
+      ),
+      bit_vec_to_nat: h(
+        "77a025c19f8be131fb9d5b0bec494817a26538b9a550abbbcec8099fae9de4e4",
+      ),
+      bit_vec_of_nat: h(
+        "90ca8130735c8d9a34005a8943b59fe1df182e08a9f2bfc7dc8323229659a574",
+      ),
+      bit_vec_ult: h(
+        "9fd8e7459a1d2deef00a4992a50419bac66c03082b58ade07422896f13033d74",
+      ),
+      decidable_decide: h(
+        "c5f7b19663e4499e70e1b2645162c5be15fa860f4f8157e331ae546c6f733723",
+      ),
+      lt_lt: h(
+        "cacaea97f4cdba0a4a0af71005d0517d1818ab2623bd2ea7fa8c637a0e3d3312",
+      ),
+      of_nat_of_nat: h(
+        "5a7292ad756ee1f2df4b92f18a27574a47cbbcf7094f98ab2865f92eb22342d7",
+      ),
+      unit: h(
+        "9232498667f765f437dedaac828e555f6cc67a20e6db28f614fdf3c262710feb",
+      ),
+      punit_size_of_1: h(
+        "7bd8e19f47f6eae620a5c39f243ce415dd6a77f09590f4c227cef363007f4012",
+      ),
+      size_of_size_of: h(
+        "389715f91e66683dc7108ccd853efce92949512fa659ad3c1902e754692919cd",
+      ),
+      string_back: h(
+        "e95c8d876e7ccf780418615e33b747a245d94facd7567fecbe7ae73a5ac09206",
+      ),
+      string_legacy_back: h(
+        "6bb6162aac7d6a01b6ec05580664e8a7f0d4b0ec1fc5afaae66018e9a1936dac",
+      ),
+      string_utf8_byte_size: h(
+        "def4433d9547b53175e24a3ac182c88b072af0d4ad33fd04ec4cf2ba3d95ea93",
+      ),
+      string_append: h(
+        "594fb1eedec7c939cc872b6c04cc3b3e0a9764fabec3e602ad9214d0e637d30f",
+      ),
+      string_dec_eq: h(
+        "82e5568d88e24f24d5befac30ce915010e92596f55a822e29f4876ea3a579394",
+      ),
+    }
+  }
+
+  /// `(lean_name, canonical_address_hex)` table from `Self::new()`,
+  /// in the same order as `Tests/Ix/Kernel/BuildPrimitives.lean`'s
+  /// `kernelPrimitives` array. Used by the regen-parity test
+  /// (`testPrimitivesParity`) to detect drift between hardcoded
+  /// addresses and freshly-compiled ones: if any future
+  /// compile/serialize change touches a primitive's content hash,
+  /// the parity test fails with a printable diff before the
+  /// breakage propagates to downstream consumers.
+  ///
+  /// Keep entries in lock-step with `kernelPrimitives` (same names,
+  /// same order). The `eager_reduce` entry is intentionally a
+  /// synthetic kernel marker — not the compiled Lean content hash —
+  /// because the real `eagerReduce` canonicalizes to the same
+  /// address as `id`; see the comment on the field in `new()`.
+  pub fn lean_parity_table() -> Vec<(&'static str, String)> {
+    let p = Self::new();
+    vec![
+      ("Nat", p.nat.hex()),
+      ("Nat.zero", p.nat_zero.hex()),
+      ("Nat.succ", p.nat_succ.hex()),
+      ("Nat.add", p.nat_add.hex()),
+      ("Nat.pred", p.nat_pred.hex()),
+      ("Nat.sub", p.nat_sub.hex()),
+      ("Nat.mul", p.nat_mul.hex()),
+      ("Nat.pow", p.nat_pow.hex()),
+      ("Nat.gcd", p.nat_gcd.hex()),
+      ("Nat.mod", p.nat_mod.hex()),
+      ("Nat.div", p.nat_div.hex()),
+      ("Nat.bitwise", p.nat_bitwise.hex()),
+      ("Nat.beq", p.nat_beq.hex()),
+      ("Nat.ble", p.nat_ble.hex()),
+      ("Nat.land", p.nat_land.hex()),
+      ("Nat.lor", p.nat_lor.hex()),
+      ("Nat.xor", p.nat_xor.hex()),
+      ("Nat.shiftLeft", p.nat_shift_left.hex()),
+      ("Nat.shiftRight", p.nat_shift_right.hex()),
+      ("Bool", p.bool_type.hex()),
+      ("Bool.true", p.bool_true.hex()),
+      ("Bool.false", p.bool_false.hex()),
+      ("String", p.string.hex()),
+      ("String.mk", p.string_mk.hex()),
+      ("Char", p.char_type.hex()),
+      ("Char.mk", p.char_mk.hex()),
+      ("Char.ofNat", p.char_of_nat.hex()),
+      ("String.ofList", p.string_of_list.hex()),
+      ("List", p.list.hex()),
+      ("List.nil", p.list_nil.hex()),
+      ("List.cons", p.list_cons.hex()),
+      ("Eq", p.eq.hex()),
+      ("Eq.refl", p.eq_refl.hex()),
+      ("Quot", p.quot_type.hex()),
+      ("Quot.mk", p.quot_ctor.hex()),
+      ("Quot.lift", p.quot_lift.hex()),
+      ("Quot.ind", p.quot_ind.hex()),
+      ("Lean.reduceBool", p.reduce_bool.hex()),
+      ("Lean.reduceNat", p.reduce_nat.hex()),
+      ("eagerReduce", p.eager_reduce.hex()),
+      ("System.Platform.numBits", p.system_platform_num_bits.hex()),
+      ("System.Platform.getNumBits", p.system_platform_get_num_bits.hex()),
+      ("Subtype.val", p.subtype_val.hex()),
+      ("String.toByteArray", p.string_to_byte_array.hex()),
+      ("ByteArray.empty", p.byte_array_empty.hex()),
+      ("Nat.decLe", p.nat_dec_le.hex()),
+      ("Nat.decEq", p.nat_dec_eq.hex()),
+      ("Nat.decLt", p.nat_dec_lt.hex()),
+      ("Decidable.rec", p.decidable_rec.hex()),
+      ("Decidable.isTrue", p.decidable_is_true.hex()),
+      ("Decidable.isFalse", p.decidable_is_false.hex()),
+      ("Nat.le_of_ble_eq_true", p.nat_le_of_ble_eq_true.hex()),
+      ("Nat.not_le_of_not_ble_eq_true", p.nat_not_le_of_not_ble_eq_true.hex()),
+      ("Nat.eq_of_beq_eq_true", p.nat_eq_of_beq_eq_true.hex()),
+      ("Nat.ne_of_beq_eq_false", p.nat_ne_of_beq_eq_false.hex()),
+      ("Fin", p.fin.hex()),
+      ("Bool.noConfusion", p.bool_no_confusion.hex()),
+      ("Int", p.int.hex()),
+      ("Int.ofNat", p.int_of_nat.hex()),
+      ("Int.negSucc", p.int_neg_succ.hex()),
+      ("Int.add", p.int_add.hex()),
+      ("Int.sub", p.int_sub.hex()),
+      ("Int.mul", p.int_mul.hex()),
+      ("Int.neg", p.int_neg.hex()),
+      ("Int.emod", p.int_emod.hex()),
+      ("Int.ediv", p.int_ediv.hex()),
+      ("Int.bmod", p.int_bmod.hex()),
+      ("Int.bdiv", p.int_bdiv.hex()),
+      ("Int.natAbs", p.int_nat_abs.hex()),
+      ("Int.pow", p.int_pow.hex()),
+      ("Int.decEq", p.int_dec_eq.hex()),
+      ("Int.decLe", p.int_dec_le.hex()),
+      ("Int.decLt", p.int_dec_lt.hex()),
+      ("PUnit", p.punit.hex()),
+      ("PProd", p.pprod.hex()),
+      ("PProd.mk", p.pprod_mk.hex()),
+      ("Nat.rec", p.nat_rec.hex()),
+      ("Nat.casesOn", p.nat_cases_on.hex()),
+      ("BitVec", p.bit_vec.hex()),
+      ("BitVec.toNat", p.bit_vec_to_nat.hex()),
+      ("BitVec.ofNat", p.bit_vec_of_nat.hex()),
+      ("BitVec.ult", p.bit_vec_ult.hex()),
+      ("Decidable.decide", p.decidable_decide.hex()),
+      ("LT.lt", p.lt_lt.hex()),
+      ("OfNat.ofNat", p.of_nat_of_nat.hex()),
+      ("Unit", p.unit.hex()),
+      ("PUnit._sizeOf_1", p.punit_size_of_1.hex()),
+      ("SizeOf.sizeOf", p.size_of_size_of.hex()),
+      ("String.back", p.string_back.hex()),
+      ("String.Legacy.back", p.string_legacy_back.hex()),
+      ("String.utf8ByteSize", p.string_utf8_byte_size.hex()),
+      ("String.append", p.string_append.hex()),
+      ("String.decEq", p.string_dec_eq.hex()),
+    ]
+  }
+
+  /// LEON content-hash addresses, hardcoded from
+  /// `ConstantInfo::get_hash()` applied to each primitive's original
+  /// (pre-compile) Lean declaration. Used by `Primitives::from_env_orig`
+  /// to resolve primitives against `orig_kenv` — the direct-ingress
+  /// environment produced by `lean_ingress` where KIds live at LEON
+  /// addresses rather than canonical addresses.
+  ///
+  /// Regenerate with `lake test -- rust-kernel-build-prim-origs`. The
+  /// failure mode when these drift is a synthetic `@<hex>` KId in every
+  /// primitive field of `orig_kenv.prims()`, which cascades into a
+  /// flood of `AppTypeMismatch` errors during original-constant
+  /// verification (any Nat literal reduction, Bool literal, `String`
+  /// coercion, or reducer-marker comparison will diverge from the real
+  /// `orig_kenv` entry for that primitive).
+  pub fn new_orig() -> Self {
+    let h = |hex: &str| -> Address {
+      Address::from_hex(hex).expect("invalid primitive address hex")
+    };
+    PrimAddrs {
+      nat: h(
+        "0c0524ffa66fdbc0c9d3f12faf1a27b2ecd331ffa06da24a78f832e4f4145589",
+      ),
+      nat_zero: h(
+        "adc9f7ba6a90c3caacf0be308c2012437e9dd810bfc2b9b286b4934be4e86cb1",
+      ),
+      nat_succ: h(
+        "e4f2b35614ae2c6487084cb96e90852643a043296bc682b469ccfd430650cf8d",
+      ),
+      nat_add: h(
+        "01ec6fdf63bc0de137becade5f420102f35338bef318b9d5fd44e70db82c3f42",
+      ),
+      nat_pred: h(
+        "26245a09319bcf9d55a08431bce3b9d8a8d09e3dad25b9a83cc666e3736deeb4",
+      ),
+      nat_sub: h(
+        "4017cc8c3a02d3eeab73d5cc5af8afe771f60d980f107fd24d3a1d59aaa41d5a",
+      ),
+      nat_mul: h(
+        "a095de37a0e713551bd237f414ac7317f68b3986ce5734ca0063c504457f24de",
+      ),
+      nat_pow: h(
+        "6e9d84492674fb8a36008214b2150c76a83da4af1cadcc303d5d680d0477235a",
+      ),
+      nat_gcd: h(
+        "09ae07bc024bfb0317aa228d1274294b40aebb4229dc7014f7b22d56fa46a760",
+      ),
+      nat_mod: h(
+        "7ee6854a6ef5afb0e83f8aae9ccc2cbb457110bd1013a6f7615a98667a34322a",
+      ),
+      nat_div: h(
+        "acb405101f168dc08bf410d54a8f588893776ab61be81f2c7e5e1dd05685560e",
+      ),
+      nat_bitwise: h(
+        "21a51ddc3faeec42c0f3897955d5e24c40ffb1924824bd919da5db0346962a98",
+      ),
+      nat_beq: h(
+        "8960bdbe7e09dd15582a50de197cb5c28d87b147e3479e417b4c2ad43011f90c",
+      ),
+      nat_ble: h(
+        "7e679407c5e5af964d3d3cb98c9b606218c6f4ac7b19210d375f1d76ddd5f022",
+      ),
+      nat_land: h(
+        "dd73c5c1552ff6ad35537b83f46c9e8c4c2c979eda612fe169e29f3028c63db9",
+      ),
+      nat_lor: h(
+        "8390650998cbee5ee2432a797635d7a331f623eb6fae9f26f17191fcdb880c60",
+      ),
+      nat_xor: h(
+        "04ffebfee34f36c46f63ef6aa347b0b81db8c1cbf3fb9a282799cac024310e69",
+      ),
+      nat_shift_left: h(
+        "89705cc0aca476aa6f161f91006980a425536757e2b7ea949d3aec0edcc3df76",
+      ),
+      nat_shift_right: h(
+        "930ab9e4c2854a0af16c84f89a5aee8e297b65411c499ffae0cf9b27d4ee4b8e",
+      ),
+      bool_type: h(
+        "95fc5d28972d1472a12ddfc2f4a5eefec9a81652fcb63ef06c7f6f6d21a951ab",
+      ),
+      bool_true: h(
+        "fc3a88e4dc16055bc8b797f9544909043015a3a349f2b3fc3e86990b2b9f2999",
+      ),
+      bool_false: h(
+        "c595b2c899f6f0ef39cfab3ac2fbe3b826a7ed21318defc64bbb861d754f8bdf",
+      ),
+      string: h(
+        "3589e6266ed0703fb4008f1e134775dff6bc9a15619687e75222f44253ab8663",
+      ),
+      string_mk: h(
+        "22d668557ab1f800aaf7312f10d9f36ec4d24d0389ac8d0b6d66fd2daf0be903",
+      ),
+      char_type: h(
+        "16e10c6b75431ae16fc23ef43f07512a1f34cff2a33d85b44aae5898e002ac8d",
+      ),
+      char_mk: h(
+        "feb0d0ed724893b5d3d57bafee59ff3cfbe76f43e03fad2b2cf237198aca4457",
+      ),
+      char_of_nat: h(
+        "3ac41b61c538227409f133982435bc97d59489b9129a61d1c4baa14fdb1d6a6a",
+      ),
+      string_of_list: h(
+        "0422aae71a49fd82c87cc8493725a927c1205a9418dc648947d7fde8ed240625",
+      ),
+      string_to_byte_array: h(
+        "714e5b7ea77110a862699b662ecc0bc5a6d70e25bbf6b69dc0f0ec5feb2cfbb3",
+      ),
+      byte_array_empty: h(
+        "5e80d9c092e5fd25417a3a011632e0d060adf9cfd4c0a0bd6798868f067a7cb2",
+      ),
+      list: h(
+        "5886afc36363b59242671f7171bedb319d2a8fa514bc4dc322e3ebcadc85e8ad",
+      ),
+      list_nil: h(
+        "c912ac74d13fa61091059bdae32484e44aea05f439cbbfff7998ef0bfb0e3409",
+      ),
+      list_cons: h(
+        "40b5c0b66834f312bbe3afcadd07911be4182695313be33394eef53d0026e988",
+      ),
+      eq: h("bc3de4d3492ebcf56e98f63459ea705005c1a4216cfc57113617738ae4d84870"),
+      eq_refl: h(
+        "3b01e364067d2ce2ac308da57512992635212487359b62a3c75f60686febef26",
+      ),
+      quot_type: h(
+        "7f7b22596ffee865e1be503216e360ab7dcbd0de645987916484c264ce52f9fe",
+      ),
+      quot_ctor: h(
+        "f06cc3564d1d269e96a51a3f41f1fae1214884ab6d555a11213b8bb2e9e517ef",
+      ),
+      quot_lift: h(
+        "ce268528ab8fe6ec17039a37e73079e3453eae1675c6c76ef302ac87e9a0bd90",
+      ),
+      quot_ind: h(
+        "4ce41a11c66a351352ab27fdfbda9d980f6e296a2fa7f20fdd41377482ed3d52",
+      ),
+      reduce_bool: h(
+        "43875997e42a7c9ea04f24b924da2299aa68e4f2dfb626d67fccfcf5b5132660",
+      ),
+      reduce_nat: h(
+        "604dc8af16829c747638e4b6d58be2baf5280077f8de9db71acb6ef8bbc5f25d",
+      ),
+      // Synthetic kernel-only marker for the original Lean-addressed env.
+      eager_reduce: h(
+        "ff00000000000000000000000000000000000000000000000000000000000013",
+      ),
+      system_platform_num_bits: h(
+        "6fb004fbafb4b68446a57550e21ac08d7599cb157ab194c52fcd7ba1671f10da",
+      ),
+      system_platform_get_num_bits: h(
+        "b9fe4dfbc707ca46de307491541e35ad89a93115245bca3860b74ebcc96a1af2",
+      ),
+      subtype_val: h(
+        "1cf910601d9d86d741333d9547d69d0e299bfe2f99a23a9e838d207fd641eac0",
+      ),
+      nat_dec_le: h(
+        "e34083eb212a258b36374129f6170a9972adceb78356b6c83aa32284ad4edee3",
+      ),
+      nat_dec_eq: h(
+        "a466eec5433bc056803f38b897d9913f91d836260c6ba4176374d1b66f98acc8",
+      ),
+      nat_dec_lt: h(
+        "759a284b4f73e6aa405b409d741fa2b35642693bd041e74b790623121c5e1e33",
+      ),
+      decidable_rec: h(
+        "19e688c7cc2966eb4f79a58eb501c776689f515a7a4cb39fdf7482f1294a1511",
+      ),
+      decidable_is_true: h(
+        "d235a7033c457dfed0f1e34d1d50e97279893b63bdcab3c4490dd9da7d47327f",
+      ),
+      decidable_is_false: h(
+        "2c26576bf92a0d9c2d169be19317e587eec54945a5a241c30dd84908d534d5a1",
+      ),
+      nat_le_of_ble_eq_true: h(
+        "16c9cae0ac27b93644943a84c426db889766476ddb12b0a8b82f76cd2d848561",
+      ),
+      nat_not_le_of_not_ble_eq_true: h(
+        "adb3eaf42d5f4c368bb929b20cec07fa96f9c9fe70d372ec72b25e6510ae14d4",
+      ),
+      nat_eq_of_beq_eq_true: h(
+        "2a2e813ddd907721551718bdb3a2f8248231a041a39563d6d68798aa48425ec8",
+      ),
+      nat_ne_of_beq_eq_false: h(
+        "a09735868d12586f23121cecf12ea2dd1f197f1d44dadc94b7e056d6cceb1980",
+      ),
+      fin: h(
+        "aca8ccd74023a139175db5f1b5b4d037ba1559e25a5d091f2bdc797b23dbb275",
+      ),
+      bool_no_confusion: h(
+        "68bd3c3b59b4bf7285096a8a0b90308db6307b082d24a08b91924b5e6cdcb53a",
+      ),
+      // Int primitives — LEON content-hashes from
+      // `lake test -- rust-kernel-build-prim-origs`. These are the
+      // addresses KIds live at in `orig_kenv`.
+      int: h(
+        "2c073df1601a9c8c7f26bdc51f22b8b7c6072fe6acbea71f244b4f67ceb1472b",
+      ),
+      int_of_nat: h(
+        "c7804dff4a217f857cb6ff58e60d9cb405bc48caffba3240e3f5601d359f9f21",
+      ),
+      int_neg_succ: h(
+        "a8fa07b6cbfec95b534e33a342ef8812aeecd00fbbd2378d71be0d45b876331a",
+      ),
+      int_add: h(
+        "5ef343c73bd4a1c1c7de0701ee822797783a988f8c71965316c7f44a64d5a9c1",
+      ),
+      int_sub: h(
+        "fbfbdc2f6d22d80e3ffb43897dfffedaf5729d5923d412c9bf5cd63ee7790bde",
+      ),
+      int_mul: h(
+        "43b5d0d51e29a259302707a64508345354061bbf2249aba25bd9962d0cdd538e",
+      ),
+      int_neg: h(
+        "8cf21639a1d062be65fa2a475a9a9945d43aa07344dac30a3eacdc512bab14de",
+      ),
+      int_emod: h(
+        "f528f52cf0c85aa71a26f9ed88d11e488c110a7b0854c74ddd0c95ff8f8d1f72",
+      ),
+      int_ediv: h(
+        "8b7ec664a8781cb34ec3678d2ce7fe4e22574ab5605c4988d841c84d8c63d6b0",
+      ),
+      int_bmod: h(
+        "61b9e1d73ecf8dff84ed4e7499c7552211695c9cdfe4a432f17e36c432efc7b2",
+      ),
+      int_bdiv: h(
+        "db0b8bb87b0d4d9fd68fa5039c3657866e122f2dea5e891bd2a0eb16569596b7",
+      ),
+      int_nat_abs: h(
+        "cc43f34a58ce42dfedfdfb0c07a5f31dffa6ba3fb272f3c573ec547eaef722d6",
+      ),
+      int_pow: h(
+        "ae92f05449a4d67697f3649225f88703a6a928a815b7cf6448e92b3a787a1103",
+      ),
+      int_dec_eq: h(
+        "6dc280a4f5be950140e02d61f81ce01b1e21ec06f338a973039bcebf13e8e08b",
+      ),
+      int_dec_le: h(
+        "dcce6645b4b207f4805c7c6878b7704ebd840903387f7848a3e544fe196f6ee3",
+      ),
+      int_dec_lt: h(
+        "ecffd44f689ee7dd7462e3a4b4620ae72637bc59c38b91e8dd5c3d98d899623d",
+      ),
+      punit: h(
+        "e4d0247a1393397d7efa718dc31229b3592a522531595290683ca63dfe420e4d",
+      ),
+      pprod: h(
+        "ce996300ab608fc33ff251a16ac724b19f169dac8ba3fa1c5be2276158adcf5c",
+      ),
+      pprod_mk: h(
+        "0a9e6c68e0531826a4b7e6cb74c5dacb7689e7ef1b78fc21f56acaf65ea25add",
+      ),
+      // Names previously matched via `is_const_named` in whnf.rs.
+      // LEON content-hashes from `lake test -- rust-kernel-build-prim-origs`.
+      nat_rec: h(
+        "02af71bf807e615ee42b36d8d5b210329cddfd1e739fc11f6ba097a2bf74fe5a",
+      ),
+      nat_cases_on: h(
+        "df2e7a477bd8b2ac4936f22c6a60a98e9055759cbcb856895497ee02bbd4af67",
+      ),
+      bit_vec: h(
+        "6f450298341dec31bbbd159414a9193b437e8541e24304c9b680a7d5384643b3",
+      ),
+      bit_vec_to_nat: h(
+        "ae3d3b7ad4c1376fe9d30b335ee19a6e5397672a5b5800f2a0276f8d249d2ed9",
+      ),
+      bit_vec_of_nat: h(
+        "b685da004503283d7a3b2b73a3ad29100762de6eced0b305aede886af05cb3ee",
+      ),
+      bit_vec_ult: h(
+        "7d0fd8eb0e739c1643319a0e6554ee7070aa575416d54c80f8f3d2b166cb7ac8",
+      ),
+      decidable_decide: h(
+        "741a3a166dabcf41a357ad70893ac52feb84068a4bc9de54596bbe602648e3d0",
+      ),
+      lt_lt: h(
+        "3f3eff2353822391e4db7f2b403cb79d2fca36c5a9a0d2dc4fce20850bb8b355",
+      ),
+      of_nat_of_nat: h(
+        "f75083bb57a4a1c5ce0b83945e39da01e11fb9f28f2ab4b57d8f0615ccda8c9d",
+      ),
+      unit: h(
+        "a9be73125f8d296246aa55a183e74d49c420b79c852c36df4fbb87a2ca1d751b",
+      ),
+      punit_size_of_1: h(
+        "6f48fa355d342f1b035ef0777c1ad72e669978816c2c09a3048c4848de4ff443",
+      ),
+      size_of_size_of: h(
+        "ac6c0f1adb8f8f74235dab15b624902bdc0832ed77fae0d62242d0e7717cb06a",
+      ),
+      string_back: h(
+        "54317bf07a28017fbfccf7d9f11c97846c106be220ab98ce1e1b58a196c12be8",
+      ),
+      string_legacy_back: h(
+        "2943dd3d52e8db4fc5b68543ec64d786ba8c70c1f304fe1c0164cc80f2aaaf17",
+      ),
+      string_utf8_byte_size: h(
+        "06ba07154a1cd0e1e9eec2b6e27b195a6fc3ae20a70d1ced7643a61e4e3e6d0f",
+      ),
+      string_append: h(
+        "93faafad0b7eff95765986eb5f5cb10635818129b72d8e7fdddaca2a5fb45844",
+      ),
+      string_dec_eq: h(
+        "a53c141a7bbbbdf77d4a2cb049911fd4001f7d71b94ed5c3b877e837da94c349",
+      ),
+    }
+  }
+}
+
+pub fn reserved_marker_name(addr: &Address) -> Option<&'static str> {
+  static MARKERS: LazyLock<[(&'static str, Address); 2]> =
+    LazyLock::new(PrimAddrs::reserved_marker_addrs);
+  MARKERS
+    .iter()
+    .find_map(|(name, marker_addr)| (marker_addr == addr).then_some(*name))
+}
diff --git a/crates/compile/src/compile.rs b/crates/compile/src/compile.rs
index 9d2f707a8..3b9773ade 100644
--- a/crates/compile/src/compile.rs
+++ b/crates/compile/src/compile.rs
@@ -194,7 +194,16 @@ pub struct BlockCache {
   /// Cache for compiled expressions (keyed by Lean hash address)
   pub exprs: FxHashMap<Address, CachedExpr>,
   /// Cache for compiled universes (Level -> Univ conversion)
-  pub univ_cache: FxHashMap<Level, Arc<Univ>>,
+  /// Keyed by `(level, univ_params_key)`, NOT by `level` alone. A
+  /// `Level::Param` compiles to `Univ::Var(i)` where `i` is the
+  /// parameter's POSITION in `univ_params`, so the result depends on the
+  /// context. This cache lives for a whole block (unlike the expression
+  /// cache, which is cleared per constant) and `compile_definition`
+  /// compiles each member under its own `level_params`, so a shared key
+  /// would hand the second member the first member's index — a silently
+  /// wrong constant under a correct-looking name, with no abort.
+  /// `collect_expr_tables` keys its `seen_exprs` the same way.
+  pub univ_cache: FxHashMap<(Level, Address), Arc<Univ>>,
   /// Cache for expression comparisons
   pub cmps: FxHashMap<(Name, Name), Ordering>,
   /// Arena for expression metadata (append-only within a constant)
@@ -412,7 +421,9 @@ pub fn compile_univ(
   univ_params: &[Name],
   cache: &mut BlockCache,
 ) -> Result<Arc<Univ>, CompileError> {
-  if let Some(cached) = cache.univ_cache.get(level) {
+  let ctx_key = univ_params_key(univ_params);
+  if let Some(cached) = cache.univ_cache.get(&(level.clone(), ctx_key.clone()))
+  {
     return Ok(cached.clone());
   }
 
@@ -449,7 +460,7 @@ pub fn compile_univ(
     },
   };
 
-  cache.univ_cache.insert(level.clone(), univ.clone());
+  cache.univ_cache.insert((level.clone(), ctx_key), univ.clone());
   Ok(univ)
 }
 
diff --git a/crates/ffi/src/aiur/protocol.rs b/crates/ffi/src/aiur/protocol.rs
index 93279cfe5..8d2fcea1b 100644
--- a/crates/ffi/src/aiur/protocol.rs
+++ b/crates/ffi/src/aiur/protocol.rs
@@ -195,7 +195,9 @@ extern "C" fn rs_aiur_system_prove(
 }
 
 // =============================================================================
-// EnvHandle constructors + with-env FFIs (PLAN.md "EnvHandle redesign")
+// EnvHandle constructors + with-env FFIs: the env is parsed once per CLI
+// invocation into an opaque Rust-owned handle, and every per-target call
+// borrows it, so no call re-parses the environment.
 // =============================================================================
 
 /// `Aiur.EnvHandle.fromIxe`: open and parse a `.ixe` file once,
@@ -467,6 +469,9 @@ extern "C" fn rs_aiur_toplevel_shard_check_with_env(
   };
   let env = &env_handle.get().env;
 
+  // Migration Phase 1: the generated kernel is the kernel, so the default
+  // shard entrypoint builds the the kernel witness (thin frontier + wrapper
+  // augmentation).
   let (_claim, input, mut io_buffer) =
     match ixvm_codegen::aiur_ixvm_witness::build_shard_check_env_witness(
       env, &owned,
diff --git a/crates/ffi/src/aiur/toplevel.rs b/crates/ffi/src/aiur/toplevel.rs
index 73124cb92..8ce24b31e 100644
--- a/crates/ffi/src/aiur/toplevel.rs
+++ b/crates/ffi/src/aiur/toplevel.rs
@@ -59,8 +59,15 @@ fn decode_op(ctor: LeanCtor<LeanBorrowed<'_>>) -> Op {
       )
     },
     8 => {
-      let [a, b] = ctor.objs::<2>();
-      Op::AssertEq(decode_vec_val_idx(a), decode_vec_val_idx(b))
+      let [a, b, msg_obj] = ctor.objs::<3>();
+      // `Option String`: scalar encodes `none`, otherwise a ctor whose
+      // single field is the string (same shape as `Op::Debug`'s label).
+      let msg = if msg_obj.is_scalar() {
+        None
+      } else {
+        Some(msg_obj.as_ctor().get(0).as_string().to_string())
+      };
+      Op::AssertEq(decode_vec_val_idx(a), decode_vec_val_idx(b), msg)
     },
     9 => {
       let [channel, key] = ctor.objs::<2>();
diff --git a/crates/ixon/src/lib.rs b/crates/ixon/src/lib.rs
index 8c5371599..5418a2326 100644
--- a/crates/ixon/src/lib.rs
+++ b/crates/ixon/src/lib.rs
@@ -20,6 +20,7 @@ pub mod merkle;
 pub mod metadata;
 pub mod proof;
 pub mod serialize;
+pub mod shard_claim;
 pub mod sharing;
 pub mod syntax;
 pub mod tag;
diff --git a/crates/ixon/src/shard_claim.rs b/crates/ixon/src/shard_claim.rs
new file mode 100644
index 000000000..ade5e2cb7
--- /dev/null
+++ b/crates/ixon/src/shard_claim.rs
@@ -0,0 +1,397 @@
+//! Shard `CheckEnv` claim convention — the single source of truth shared
+//! by every builder (Lean `IxVM.ClaimHarness.shardCheckEnvClaim`,
+//! `ixvm-codegen::aiur_ixvm_witness::build_shard_check_env_witness`,
+//! `ix-kernel::claim`). Any change here changes claim digests; keep the
+//! Lean mirror in lockstep.
+//!
+//! Semantics (mirrors the Aiur kernel's `env_walk`):
+//!
+//! - **Walk edge relation**: the `refs` entries some Expr uses AS A
+//!   CONSTANT (`Ref(i, ..)` or `Prj(i, ..)`), plus — for a projection
+//!   wrapper (IPrj/CPrj/RPrj/DPrj) — its `block` pointer. `Str`/`Nat`
+//!   entries index blob payloads and entries no Expr names are never
+//!   walked, so neither is an edge; admitting them would put phantom
+//!   members in the frontier the kernel never visits.
+//!   NOT `Env::closure_edges`: that also derives Muts member-projection
+//!   addresses, which the claim walk does not traverse (a Muts block's
+//!   members are checked in place; recursion leaves the block only
+//!   through its `refs`).
+//! - **Walk**: start from every owned constant; skip addrs absent from
+//!   `env.consts` (blob payloads); stop at any asm member (assumed
+//!   well-typed by its owning shard — not checked, not recursed).
+//! - **Strict membership**: a walk-reachable constant in neither
+//!   `owned` nor `asm` means the owned tree does not cover its own
+//!   closure (bad frontier) — hard error, never silently absorbed.
+//! - **Thin frontier**: the asm set is the DIRECT out-of-owned walk
+//!   edges of the owned constants. The walk can only exit the shard
+//!   through one of these, so anything below the first layer is dead
+//!   weight in the asm tree. Sub-frontier constants are covered
+//!   transitively by the frontier members' own shard claims.
+//! - **Byte scope ≠ check scope**: delta unfolding in the kernel reads
+//!   through the frontier (a frontier Defn's body may reference
+//!   sub-frontier constants at any depth), so a WITNESS must ship the
+//!   full dependency closure of `owned` — see `Env::bfs_closure` — even
+//!   though only the strict-membership set gets checked.
+
+use rustc_hash::FxHashSet;
+
+use crate::constant::{
+  Constant, ConstantInfo, Definition, Inductive, MutConst, Recursor,
+};
+use crate::env::Env;
+use crate::expr::Expr;
+use crate::merkle::merkle_root_canonical;
+use crate::proof::Claim;
+use ix_common::address::Address;
+
+/// Collect the `refs` indices this Expr uses as a CONSTANT: `Ref(i, _)`
+/// and the type index of `Prj(i, _, _)`. `Str`/`Nat` index blob payloads
+/// and `Rec` resolves through the block's members, so neither
+/// contributes. `Share` is not followed — every shared subexpression is
+/// itself an entry of `Constant.sharing`, which is walked separately, so
+/// coverage is complete and the traversal stays linear.
+///
+/// Mirror of `const_idxs_expr` in `Ix/IxVM/Kernel/Claim.lean`.
+fn const_idxs_expr(e: &Expr, out: &mut FxHashSet<u64>) {
+  match e {
+    Expr::Ref(i, _) => {
+      out.insert(*i);
+    },
+    Expr::Prj(i, _, inner) => {
+      out.insert(*i);
+      const_idxs_expr(inner, out);
+    },
+    Expr::App(a, b) | Expr::Lam(a, b) | Expr::All(a, b) => {
+      const_idxs_expr(a, out);
+      const_idxs_expr(b, out);
+    },
+    Expr::Let(_, t, v, b) => {
+      const_idxs_expr(t, out);
+      const_idxs_expr(v, out);
+      const_idxs_expr(b, out);
+    },
+    _ => {},
+  }
+}
+
+/// The `refs` indices a constant uses as constants, over its `sharing`
+/// table and every Expr its `ConstantInfo` carries.
+///
+/// Mirror of `const_idxs_of` in `Ix/IxVM/Kernel/Claim.lean`.
+fn const_idxs_of(c: &Constant) -> FxHashSet<u64> {
+  let mut out = FxHashSet::default();
+  for e in &c.sharing {
+    const_idxs_expr(e, &mut out);
+  }
+  let defn = |d: &Definition, out: &mut FxHashSet<u64>| {
+    const_idxs_expr(&d.typ, out);
+    const_idxs_expr(&d.value, out);
+  };
+  let recr = |r: &Recursor, out: &mut FxHashSet<u64>| {
+    const_idxs_expr(&r.typ, out);
+    for rule in &r.rules {
+      const_idxs_expr(&rule.rhs, out);
+    }
+  };
+  let indc = |i: &Inductive, out: &mut FxHashSet<u64>| {
+    const_idxs_expr(&i.typ, out);
+    for ctor in &i.ctors {
+      const_idxs_expr(&ctor.typ, out);
+    }
+  };
+  match &c.info {
+    ConstantInfo::Defn(d) => defn(d, &mut out),
+    ConstantInfo::Recr(r) => recr(r, &mut out),
+    ConstantInfo::Axio(a) => const_idxs_expr(&a.typ, &mut out),
+    ConstantInfo::Quot(q) => const_idxs_expr(&q.typ, &mut out),
+    ConstantInfo::Muts(members) => {
+      for m in members {
+        match m {
+          MutConst::Defn(d) => defn(d, &mut out),
+          MutConst::Indc(i) => indc(i, &mut out),
+          MutConst::Recr(r) => recr(r, &mut out),
+        }
+      }
+    },
+    // Projection wrappers carry no Exprs of their own.
+    _ => {},
+  }
+  out
+}
+
+/// The claim walk's edge relation: the `refs` entries used as constants,
+/// plus a projection's `block`.
+///
+/// Only positively-used indices are edges, matching the kernel's
+/// `env_walk_refs` / `walk_refs_transitive`. Treating every `refs` entry
+/// as an edge would over-approximate against a prover-authored constant —
+/// a `refs` entry no Expr uses as a constant is never walked in-circuit,
+/// so admitting it here would put a phantom member in the thin frontier
+/// (and thus a phantom cross-shard assumption edge) that the kernel never
+/// produces.
+pub fn walk_edges(c: &Constant, edges: &mut Vec<Address>) {
+  let used = const_idxs_of(c);
+  for (i, a) in c.refs.iter().enumerate() {
+    if used.contains(&(i as u64)) {
+      edges.push(a.clone());
+    }
+  }
+  match &c.info {
+    ConstantInfo::IPrj(p) => edges.push(p.block.clone()),
+    ConstantInfo::CPrj(p) => edges.push(p.block.clone()),
+    ConstantInfo::RPrj(p) => edges.push(p.block.clone()),
+    ConstantInfo::DPrj(p) => edges.push(p.block.clone()),
+    _ => {},
+  }
+}
+
+/// The THIN frontier: direct out-of-owned walk edges of the owned
+/// constants, restricted to addrs present in `env.consts` (the walk's
+/// blob sentinel fires before its membership test, so blob addrs never
+/// consult the asm set). Sorted for canonical tree construction.
+pub fn thin_frontier(env: &Env, owned: &[Address]) -> Vec<Address> {
+  let owned_set: FxHashSet<&Address> = owned.iter().collect();
+  let mut frontier: FxHashSet<Address> = FxHashSet::default();
+  for o in owned {
+    let Some(c) = env.get_const(o) else {
+      continue;
+    };
+    let mut edges = Vec::new();
+    walk_edges(&c, &mut edges);
+    for e in edges {
+      if !owned_set.contains(&e) && env.consts.get(&e).is_some() {
+        frontier.insert(e);
+      }
+    }
+  }
+  let mut v: Vec<Address> = frontier.into_iter().collect();
+  v.sort_unstable();
+  v
+}
+
+/// Build the shard `CheckEnv` claim: root over the (sorted) owned set,
+/// assumptions over the thin frontier. Returns the claim plus the
+/// frontier leaves (the caller ships the asm tree it commits to).
+/// `None` on an empty owned set.
+pub fn shard_check_env_claim(
+  env: &Env,
+  owned: &[Address],
+) -> Option<(Claim, Vec<Address>)> {
+  let mut owned_sorted: Vec<Address> = owned.to_vec();
+  owned_sorted.sort_unstable();
+  let root = merkle_root_canonical(&owned_sorted)?;
+  let frontier = thin_frontier(env, owned);
+  let assumptions = merkle_root_canonical(&frontier);
+  Some((Claim::CheckEnv { root, assumptions }, frontier))
+}
+
+/// Error from `walk_check_set`: a walk-reachable constant in neither
+/// `owned` nor `asm` — the claim's owned tree does not cover its own
+/// closure up to the given frontier.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct StrictMembershipError {
+  pub addr: Address,
+}
+
+/// The claim-exact CHECK set: exactly the constants a `CheckEnv { root
+/// over owned, assumptions over asm }` claim requires well-typed in
+/// THIS shard. Walk from every owned constant over `walk_edges`,
+/// skipping blob addrs, stopping at asm members; every visited
+/// constant must be owned (strict membership) or the walk errors.
+///
+/// Checker-agnostic: the Aiur kernel interleaves this walk with
+/// checking (`env_walk`); a native checker can compute the set
+/// first and then check each member. Both must agree on the SET — that
+/// is the claim semantics.
+pub fn walk_check_set(
+  env: &Env,
+  owned: &[Address],
+  asm: &[Address],
+) -> Result<Vec<Address>, StrictMembershipError> {
+  let owned_set: FxHashSet<&Address> = owned.iter().collect();
+  let asm_set: FxHashSet<&Address> = asm.iter().collect();
+  let mut visited: FxHashSet<Address> = FxHashSet::default();
+  let mut out: Vec<Address> = Vec::new();
+  let mut stack: Vec<Address> = owned.to_vec();
+  while let Some(addr) = stack.pop() {
+    if visited.contains(&addr) {
+      continue;
+    }
+    // Blob sentinel first: absent-from-consts addrs are payloads, not
+    // constants — never checked, never consulted for membership.
+    let Some(c) = env.get_const(&addr) else {
+      visited.insert(addr);
+      continue;
+    };
+    // Asm cutoff: assumed well-typed elsewhere; no check, no recursion.
+    if asm_set.contains(&addr) {
+      visited.insert(addr);
+      continue;
+    }
+    if !owned_set.contains(&addr) {
+      return Err(StrictMembershipError { addr });
+    }
+    visited.insert(addr.clone());
+    out.push(addr);
+    let mut edges = Vec::new();
+    walk_edges(&c, &mut edges);
+    for e in edges {
+      if !visited.contains(&e) {
+        stack.push(e);
+      }
+    }
+  }
+  out.sort_unstable();
+  Ok(out)
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+  use crate::constant::{Axiom, Constant, ConstantInfo};
+  use crate::expr::Expr;
+  use std::sync::Arc;
+
+  /// A constant whose type NAMES every one of its `refs` entries via a
+  /// `Ref` node. The walk admits an index only when some Expr uses it as
+  /// a constant, so a fixture whose Exprs ignore `refs` would produce no
+  /// edges at all.
+  fn const_with_refs(refs: Vec<Address>) -> Constant {
+    let mut typ: Arc<Expr> = Arc::new(Expr::Sort(0));
+    for i in 0..refs.len() {
+      typ = Arc::new(Expr::App(typ, Arc::new(Expr::Ref(i as u64, Vec::new()))));
+    }
+    Constant::with_tables(
+      ConstantInfo::Axio(Axiom { is_unsafe: false, lvls: 0, typ }),
+      Vec::new(),
+      refs,
+      Vec::new(),
+    )
+  }
+
+  /// `refs` carries every address, but only index 0 is named by a `Ref`.
+  fn const_using_only_first(refs: Vec<Address>) -> Constant {
+    Constant::with_tables(
+      ConstantInfo::Axio(Axiom {
+        is_unsafe: false,
+        lvls: 0,
+        typ: Arc::new(Expr::Ref(0, Vec::new())),
+      }),
+      Vec::new(),
+      refs,
+      Vec::new(),
+    )
+  }
+
+  /// a -> b -> c, d isolated.
+  fn chain_env() -> (Env, Address, Address, Address, Address) {
+    let env = Env::new();
+    let a = Address::hash(b"a");
+    let b = Address::hash(b"b");
+    let c = Address::hash(b"c");
+    let d = Address::hash(b"d");
+    env.store_const(a.clone(), const_with_refs(vec![b.clone()]));
+    env.store_const(b.clone(), const_with_refs(vec![c.clone()]));
+    env.store_const(c.clone(), const_with_refs(vec![]));
+    env.store_const(d.clone(), const_with_refs(vec![]));
+    (env, a, b, c, d)
+  }
+
+  #[test]
+  fn thin_frontier_is_first_layer_only() {
+    let (env, a, b, c, _) = chain_env();
+    // owned = {a}: frontier is {b}, NOT {b, c}.
+    let f = thin_frontier(&env, &[a]);
+    assert_eq!(f, vec![b]);
+    assert!(!f.contains(&c));
+  }
+
+  #[test]
+  fn thin_frontier_excludes_owned_and_absent() {
+    let (env, a, b, _, _) = chain_env();
+    let blob = Address::hash(b"blob-not-in-env");
+    env.store_const(a.clone(), const_with_refs(vec![b.clone(), blob.clone()]));
+    let f = thin_frontier(&env, &[a.clone(), b.clone()]);
+    // b is owned; blob is absent; a's only external const edge is c via b.
+    assert!(!f.contains(&a));
+    assert!(!f.contains(&b));
+    assert!(!f.contains(&blob));
+  }
+
+  /// A `refs` entry that is a real constant but that no Expr uses as one
+  /// is never walked in-circuit, so it must not appear in the frontier.
+  /// Admitting it would commit the claim to a cross-shard assumption the
+  /// kernel never makes — a phantom dependency edge, and a potential
+  /// phantom cycle once assumptions are discharged.
+  #[test]
+  fn thin_frontier_excludes_unused_ref_entries() {
+    let env = Env::new();
+    let a = Address::hash(b"a");
+    let used = Address::hash(b"used");
+    let dead = Address::hash(b"dead");
+    env.store_const(used.clone(), const_with_refs(vec![]));
+    env.store_const(dead.clone(), const_with_refs(vec![]));
+    env.store_const(
+      a.clone(),
+      const_using_only_first(vec![used.clone(), dead.clone()]),
+    );
+
+    let f = thin_frontier(&env, &[a]);
+    assert!(f.contains(&used), "positively-used ref missing from frontier");
+    assert!(
+      !f.contains(&dead),
+      "unused refs entry became a phantom frontier member"
+    );
+  }
+
+  #[test]
+  fn walk_check_set_stops_at_frontier() {
+    let (env, a, b, c, _) = chain_env();
+    // owned = {a}, asm = {b}: check exactly {a}; c never visited.
+    let set = walk_check_set(&env, std::slice::from_ref(&a), &[b]).unwrap();
+    assert_eq!(set, vec![a]);
+    assert!(!set.contains(&c));
+  }
+
+  #[test]
+  fn walk_check_set_strict_membership_errors() {
+    let (env, a, b, _, _) = chain_env();
+    // owned = {a}, asm = {} — b is reachable but in neither set.
+    let err = walk_check_set(&env, &[a], &[]).unwrap_err();
+    assert_eq!(err.addr, b);
+  }
+
+  #[test]
+  fn walk_check_set_self_contained_checks_all() {
+    let (env, a, b, c, _) = chain_env();
+    let set =
+      walk_check_set(&env, &[a.clone(), b.clone(), c.clone()], &[]).unwrap();
+    let mut expected = vec![a, b, c];
+    expected.sort_unstable();
+    assert_eq!(set, expected);
+  }
+
+  #[test]
+  fn claim_deterministic_and_thin() {
+    let (env, a, b, _, _) = chain_env();
+    let (claim1, f1) =
+      shard_check_env_claim(&env, std::slice::from_ref(&a)).unwrap();
+    let (claim2, f2) = shard_check_env_claim(&env, &[a]).unwrap();
+    assert_eq!(claim1, claim2);
+    assert_eq!(f1, f2);
+    assert_eq!(f1, vec![b]);
+  }
+
+  #[test]
+  fn byte_scope_goes_below_frontier() {
+    let (env, a, _, c, _) = chain_env();
+    // Byte scope includes c even though the check walk (asm = {b})
+    // never visits it.
+    let cl = env.bfs_closure(&[a]);
+    assert!(cl.contains(&c));
+  }
+}
diff --git a/crates/ixvm-codegen/src/aiur_ixvm.rs b/crates/ixvm-codegen/src/aiur_ixvm.rs
index c76cf7db9..681c05f46 100644
--- a/crates/ixvm-codegen/src/aiur_ixvm.rs
+++ b/crates/ixvm-codegen/src/aiur_ixvm.rs
@@ -16,8 +16,8 @@ use multi_stark::p3_field::{PrimeCharacteristicRing, PrimeField64};
 use aiur::G;
 use aiur::execute::{ ExecError, IOBuffer, QueryRecord, bytes1_bit_decompose_value, bytes2_xor_value, bytes2_and_value, bytes2_or_value, bytes2_less_than_value, bytes2_add_value, bytes2_sub_value, bytes2_chain_rotr7_value, bytes2_chain_rotr4_value, unconstrained_big_uint_div_mod_helper, CodegenBytes1 as Bytes1, CodegenBytes2 as Bytes2 };
 
-const INPUT_SIZE_0: usize = 3;
-const IN_0: usize = 3;
+const INPUT_SIZE_0: usize = 2;
+const IN_0: usize = 2;
 const OUT_0: usize = 1;
 fn aiur_fn_0(
   inp: [G; IN_0],
@@ -25,6 +25,399 @@ fn aiur_fn_0(
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
 ) -> Result<[G; OUT_0], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    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_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];
+    let __v_12: G = __loaded[10];
+    let __v_13: G = __loaded[11];
+    let __v_14: G = __loaded[12];
+    let __v_15: G = __loaded[13];
+    let __v_16: G = __loaded[14];
+    let __v_17: G = __loaded[15];
+    let __v_18: G = __loaded[16];
+    let __v_19: G = __loaded[17];
+    let __v_20: G = __loaded[18];
+    let __v_21: G = __loaded[19];
+    let __v_22: G = __loaded[20];
+    let __v_23: G = __loaded[21];
+    let __v_24: G = __loaded[22];
+    let __v_25: G = __loaded[23];
+    let __v_26: G = __loaded[24];
+    let __v_27: G = __loaded[25];
+    let __v_28: G = __loaded[26];
+    let __v_29: G = __loaded[27];
+    let __v_30: G = __loaded[28];
+    let __v_31: G = __loaded[29];
+    let __v_32: G = __loaded[30];
+    let __v_33: 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_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 = G::from_u64(256);
+    let __v_67: G = (__v_9 * __v_66);
+    let __v_68: G = (__v_67 + __v_8);
+    let __v_69: G = G::from_u64(256);
+    let __v_70: G = (__v_68 * __v_69);
+    let __v_71: G = (__v_70 + __v_7);
+    let __v_72: G = G::from_u64(256);
+    let __v_73: G = (__v_71 * __v_72);
+    let __v_74: G = (__v_73 + __v_6);
+    let __v_75: G = G::from_u64(256);
+    let __v_76: G = (__v_74 * __v_75);
+    let __v_77: G = (__v_76 + __v_5);
+    let __v_78: G = G::from_u64(256);
+    let __v_79: G = (__v_77 * __v_78);
+    let __v_80: G = (__v_79 + __v_4);
+    let __v_81: G = G::from_u64(256);
+    let __v_82: G = (__v_80 * __v_81);
+    let __v_83: G = (__v_82 + __v_3);
+    let __v_84: G = G::from_u64(256);
+    let __v_85: G = (__v_41 * __v_84);
+    let __v_86: G = (__v_85 + __v_40);
+    let __v_87: G = G::from_u64(256);
+    let __v_88: G = (__v_86 * __v_87);
+    let __v_89: G = (__v_88 + __v_39);
+    let __v_90: G = G::from_u64(256);
+    let __v_91: G = (__v_89 * __v_90);
+    let __v_92: G = (__v_91 + __v_38);
+    let __v_93: G = G::from_u64(256);
+    let __v_94: G = (__v_92 * __v_93);
+    let __v_95: G = (__v_94 + __v_37);
+    let __v_96: G = G::from_u64(256);
+    let __v_97: G = (__v_95 * __v_96);
+    let __v_98: G = (__v_97 + __v_36);
+    let __v_99: G = G::from_u64(256);
+    let __v_100: G = (__v_98 * __v_99);
+    let __v_101: G = (__v_100 + __v_35);
+    let __v_102: G = (__v_83 - __v_101);
+    match __v_102.as_canonical_u64() {
+      0u64 => {
+        let __v_103: G = G::from_u64(256);
+        let __v_104: G = (__v_16 * __v_103);
+        let __v_105: G = (__v_104 + __v_15);
+        let __v_106: G = G::from_u64(256);
+        let __v_107: G = (__v_105 * __v_106);
+        let __v_108: G = (__v_107 + __v_14);
+        let __v_109: G = G::from_u64(256);
+        let __v_110: G = (__v_108 * __v_109);
+        let __v_111: G = (__v_110 + __v_13);
+        let __v_112: G = G::from_u64(256);
+        let __v_113: G = (__v_111 * __v_112);
+        let __v_114: G = (__v_113 + __v_12);
+        let __v_115: G = G::from_u64(256);
+        let __v_116: G = (__v_114 * __v_115);
+        let __v_117: G = (__v_116 + __v_11);
+        let __v_118: G = G::from_u64(256);
+        let __v_119: G = (__v_117 * __v_118);
+        let __v_120: G = (__v_119 + __v_10);
+        let __v_121: G = G::from_u64(256);
+        let __v_122: G = (__v_48 * __v_121);
+        let __v_123: G = (__v_122 + __v_47);
+        let __v_124: G = G::from_u64(256);
+        let __v_125: G = (__v_123 * __v_124);
+        let __v_126: G = (__v_125 + __v_46);
+        let __v_127: G = G::from_u64(256);
+        let __v_128: G = (__v_126 * __v_127);
+        let __v_129: G = (__v_128 + __v_45);
+        let __v_130: G = G::from_u64(256);
+        let __v_131: G = (__v_129 * __v_130);
+        let __v_132: G = (__v_131 + __v_44);
+        let __v_133: G = G::from_u64(256);
+        let __v_134: G = (__v_132 * __v_133);
+        let __v_135: G = (__v_134 + __v_43);
+        let __v_136: G = G::from_u64(256);
+        let __v_137: G = (__v_135 * __v_136);
+        let __v_138: G = (__v_137 + __v_42);
+        let __v_139: G = (__v_120 - __v_138);
+        match __v_139.as_canonical_u64() {
+          0u64 => {
+            let __v_140: G = G::from_u64(256);
+            let __v_141: G = (__v_23 * __v_140);
+            let __v_142: G = (__v_141 + __v_22);
+            let __v_143: G = G::from_u64(256);
+            let __v_144: G = (__v_142 * __v_143);
+            let __v_145: G = (__v_144 + __v_21);
+            let __v_146: G = G::from_u64(256);
+            let __v_147: G = (__v_145 * __v_146);
+            let __v_148: G = (__v_147 + __v_20);
+            let __v_149: G = G::from_u64(256);
+            let __v_150: G = (__v_148 * __v_149);
+            let __v_151: G = (__v_150 + __v_19);
+            let __v_152: G = G::from_u64(256);
+            let __v_153: G = (__v_151 * __v_152);
+            let __v_154: G = (__v_153 + __v_18);
+            let __v_155: G = G::from_u64(256);
+            let __v_156: G = (__v_154 * __v_155);
+            let __v_157: G = (__v_156 + __v_17);
+            let __v_158: G = G::from_u64(256);
+            let __v_159: G = (__v_55 * __v_158);
+            let __v_160: G = (__v_159 + __v_54);
+            let __v_161: G = G::from_u64(256);
+            let __v_162: G = (__v_160 * __v_161);
+            let __v_163: G = (__v_162 + __v_53);
+            let __v_164: G = G::from_u64(256);
+            let __v_165: G = (__v_163 * __v_164);
+            let __v_166: G = (__v_165 + __v_52);
+            let __v_167: G = G::from_u64(256);
+            let __v_168: G = (__v_166 * __v_167);
+            let __v_169: G = (__v_168 + __v_51);
+            let __v_170: G = G::from_u64(256);
+            let __v_171: G = (__v_169 * __v_170);
+            let __v_172: G = (__v_171 + __v_50);
+            let __v_173: G = G::from_u64(256);
+            let __v_174: G = (__v_172 * __v_173);
+            let __v_175: G = (__v_174 + __v_49);
+            let __v_176: G = (__v_157 - __v_175);
+            match __v_176.as_canonical_u64() {
+              0u64 => {
+                let __v_177: G = G::from_u64(256);
+                let __v_178: G = (__v_30 * __v_177);
+                let __v_179: G = (__v_178 + __v_29);
+                let __v_180: G = G::from_u64(256);
+                let __v_181: G = (__v_179 * __v_180);
+                let __v_182: G = (__v_181 + __v_28);
+                let __v_183: G = G::from_u64(256);
+                let __v_184: G = (__v_182 * __v_183);
+                let __v_185: G = (__v_184 + __v_27);
+                let __v_186: G = G::from_u64(256);
+                let __v_187: G = (__v_185 * __v_186);
+                let __v_188: G = (__v_187 + __v_26);
+                let __v_189: G = G::from_u64(256);
+                let __v_190: G = (__v_188 * __v_189);
+                let __v_191: G = (__v_190 + __v_25);
+                let __v_192: G = G::from_u64(256);
+                let __v_193: G = (__v_191 * __v_192);
+                let __v_194: G = (__v_193 + __v_24);
+                let __v_195: G = G::from_u64(256);
+                let __v_196: G = (__v_62 * __v_195);
+                let __v_197: G = (__v_196 + __v_61);
+                let __v_198: G = G::from_u64(256);
+                let __v_199: G = (__v_197 * __v_198);
+                let __v_200: G = (__v_199 + __v_60);
+                let __v_201: G = G::from_u64(256);
+                let __v_202: G = (__v_200 * __v_201);
+                let __v_203: G = (__v_202 + __v_59);
+                let __v_204: G = G::from_u64(256);
+                let __v_205: G = (__v_203 * __v_204);
+                let __v_206: G = (__v_205 + __v_58);
+                let __v_207: G = G::from_u64(256);
+                let __v_208: G = (__v_206 * __v_207);
+                let __v_209: G = (__v_208 + __v_57);
+                let __v_210: G = G::from_u64(256);
+                let __v_211: G = (__v_209 * __v_210);
+                let __v_212: G = (__v_211 + __v_56);
+                let __v_213: G = (__v_194 - __v_212);
+                match __v_213.as_canonical_u64() {
+                  0u64 => {
+                    let __v_214: G = G::from_u64(256);
+                    let __v_215: G = (__v_33 * __v_214);
+                    let __v_216: G = (__v_215 + __v_32);
+                    let __v_217: G = G::from_u64(256);
+                    let __v_218: G = (__v_216 * __v_217);
+                    let __v_219: G = (__v_218 + __v_31);
+                    let __v_220: G = G::from_u64(256);
+                    let __v_221: G = (__v_65 * __v_220);
+                    let __v_222: G = (__v_221 + __v_64);
+                    let __v_223: G = G::from_u64(256);
+                    let __v_224: G = (__v_222 * __v_223);
+                    let __v_225: G = (__v_224 + __v_63);
+                    let __v_226: G = (__v_219 - __v_225);
+                    match __v_226.as_canonical_u64() {
+                      0u64 => {
+                        let __v_227: G = G::from_u64(1);
+                        let __ret: [G; OUT_0] = [__v_227];
+                        record.function_queries[0].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        return Ok(__ret);
+                      },
+                      _ => {
+                        let __v_227: G = G::from_u64(0);
+                        let __ret: [G; OUT_0] = [__v_227];
+                        record.function_queries[0].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        return Ok(__ret);
+                      },
+                    }
+                  },
+                  _ => {
+                    let __v_214: G = G::from_u64(0);
+                    let __ret: [G; OUT_0] = [__v_214];
+                    record.function_queries[0].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
+                  },
+                }
+              },
+              _ => {
+                let __v_177: G = G::from_u64(0);
+                let __ret: [G; OUT_0] = [__v_177];
+                record.function_queries[0].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+            }
+          },
+          _ => {
+            let __v_140: G = G::from_u64(0);
+            let __ret: [G; OUT_0] = [__v_140];
+            record.function_queries[0].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+        }
+      },
+      _ => {
+        let __v_103: G = G::from_u64(0);
+        let __ret: [G; OUT_0] = [__v_103];
+        record.function_queries[0].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_1: usize = 2;
+const IN_1: usize = 2;
+const OUT_1: usize = 1;
+fn aiur_fn_1(
+  inp: [G; IN_1],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_1], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    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_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];
+    let __v_12: G = __loaded[10];
+    let __v_13: G = __loaded[11];
+    let __v_14: G = __loaded[12];
+    let __v_15: G = __loaded[13];
+    let __v_16: G = __loaded[14];
+    let __v_17: G = __loaded[15];
+    let __v_18: G = __loaded[16];
+    let __v_19: G = __loaded[17];
+    let __v_20: G = __loaded[18];
+    let __v_21: G = __loaded[19];
+    let __v_22: G = __loaded[20];
+    let __v_23: G = __loaded[21];
+    let __v_24: G = __loaded[22];
+    let __v_25: G = __loaded[23];
+    let __v_26: G = __loaded[24];
+    let __v_27: G = __loaded[25];
+    let __v_28: G = __loaded[26];
+    let __v_29: G = __loaded[27];
+    let __v_30: G = __loaded[28];
+    let __v_31: G = __loaded[29];
+    let __v_32: G = __loaded[30];
+    let __v_33: 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_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 = (__v_2 - __v_34);
+    match __v_66.as_canonical_u64() {
+      0u64 => {
+        let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_0] = unsafe { *(result.output.as_ptr() as *const [G; OUT_0]) }; __ret } else { aiur_fn_0(__args, record, io_buffer, __cu)? } };
+        let __v_67: G = __r_arr[0];
+        let __ret: [G; OUT_1] = [__v_67];
+        record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __v_67: G = G::from_u64(0);
+        let __ret: [G; OUT_1] = [__v_67];
+        record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_2: usize = 3;
+const IN_2: usize = 3;
+const OUT_2: usize = 1;
+fn aiur_fn_2(
+  inp: [G; IN_2],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_2], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -34,8 +427,8 @@ fn aiur_fn_0(
         let __v_3: G = G::from_u64(1);
         let __v_4: G = G::from_u64(1);
         let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __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 __ret: [G; OUT_0] = [__v_5];
-        record.function_queries[0].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_2] = [__v_5];
+        record.function_queries[2].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -43,29 +436,29 @@ fn aiur_fn_0(
         let __v_4: G = (__v_1 + __v_3);
         let __v_5: G = G::from_u64(1);
         let __v_6: G = (__v_2 - __v_5);
-        let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_0, __v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_0] = unsafe { *(result.output.as_ptr() as *const [G; OUT_0]) }; __ret } else { aiur_fn_0(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
         let __io_read: [G; 1] = { let __idx_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__idx_u64).ok().ok_or(ExecError::IndexTooLarge(__idx_u64))?; let __data = io_buffer.read(__v_0, __idx, 1)?; let __arr: [G; 1] = __data[..1].try_into().unwrap(); __arr };
         let __v_8: G = __io_read[0];
         let __v_9: G = G::from_u64(0);
         let __v_10: G = { let __values: [G; 3] = [__v_9, __v_8, __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_0] = [__v_10];
-        record.function_queries[0].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_2] = [__v_10];
+        record.function_queries[2].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_1: usize = 8;
-const IN_1: usize = 8;
-const OUT_1: usize = 1;
-fn aiur_fn_1(
-  inp: [G; IN_1],
+const INPUT_SIZE_3: usize = 8;
+const IN_3: usize = 8;
+const OUT_3: usize = 1;
+fn aiur_fn_3(
+  inp: [G; IN_3],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_1], ExecError> {
+) -> Result<[G; OUT_3], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -90,14 +483,14 @@ fn aiur_fn_1(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(1);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -106,14 +499,14 @@ fn aiur_fn_1(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(7);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -126,14 +519,14 @@ fn aiur_fn_1(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(6);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -142,14 +535,14 @@ fn aiur_fn_1(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(7);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -166,14 +559,14 @@ fn aiur_fn_1(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(5);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -182,14 +575,14 @@ fn aiur_fn_1(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(7);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -202,14 +595,14 @@ fn aiur_fn_1(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(6);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -218,14 +611,14 @@ fn aiur_fn_1(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(7);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -246,14 +639,14 @@ fn aiur_fn_1(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(4);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -262,14 +655,14 @@ fn aiur_fn_1(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(7);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -282,14 +675,14 @@ fn aiur_fn_1(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(6);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -298,14 +691,14 @@ fn aiur_fn_1(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(7);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -322,14 +715,14 @@ fn aiur_fn_1(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(5);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -338,14 +731,14 @@ fn aiur_fn_1(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(7);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -358,14 +751,14 @@ fn aiur_fn_1(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(6);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -374,14 +767,14 @@ fn aiur_fn_1(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(7);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -406,14 +799,14 @@ fn aiur_fn_1(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(3);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -422,14 +815,14 @@ fn aiur_fn_1(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(7);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -442,14 +835,14 @@ fn aiur_fn_1(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(6);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -458,14 +851,14 @@ fn aiur_fn_1(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(7);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -482,14 +875,14 @@ fn aiur_fn_1(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(5);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -498,14 +891,14 @@ fn aiur_fn_1(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(7);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -518,14 +911,14 @@ fn aiur_fn_1(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(6);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -534,14 +927,14 @@ fn aiur_fn_1(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(7);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -562,14 +955,14 @@ fn aiur_fn_1(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(4);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -578,14 +971,14 @@ fn aiur_fn_1(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(7);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -598,14 +991,14 @@ fn aiur_fn_1(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(6);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -614,14 +1007,14 @@ fn aiur_fn_1(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(7);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -638,14 +1031,14 @@ fn aiur_fn_1(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(5);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -654,14 +1047,14 @@ fn aiur_fn_1(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(7);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -674,14 +1067,14 @@ fn aiur_fn_1(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(6);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -690,14 +1083,14 @@ fn aiur_fn_1(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(7);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -726,14 +1119,14 @@ fn aiur_fn_1(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(2);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -742,14 +1135,14 @@ fn aiur_fn_1(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(7);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -762,14 +1155,14 @@ fn aiur_fn_1(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(6);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -778,14 +1171,14 @@ fn aiur_fn_1(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(7);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -802,14 +1195,14 @@ fn aiur_fn_1(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(5);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -818,14 +1211,14 @@ fn aiur_fn_1(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(7);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -838,14 +1231,14 @@ fn aiur_fn_1(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(6);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -854,14 +1247,14 @@ fn aiur_fn_1(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(7);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -882,14 +1275,14 @@ fn aiur_fn_1(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(4);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -898,14 +1291,14 @@ fn aiur_fn_1(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(7);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -918,14 +1311,14 @@ fn aiur_fn_1(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(6);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -934,14 +1327,14 @@ fn aiur_fn_1(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(7);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -958,14 +1351,14 @@ fn aiur_fn_1(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(5);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -974,14 +1367,14 @@ fn aiur_fn_1(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(7);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -994,14 +1387,14 @@ fn aiur_fn_1(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(6);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -1010,14 +1403,14 @@ fn aiur_fn_1(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(7);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -1042,14 +1435,14 @@ fn aiur_fn_1(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(3);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -1058,14 +1451,14 @@ fn aiur_fn_1(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(7);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -1078,14 +1471,14 @@ fn aiur_fn_1(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(6);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -1094,14 +1487,14 @@ fn aiur_fn_1(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(7);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -1118,14 +1511,14 @@ fn aiur_fn_1(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(5);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -1134,14 +1527,14 @@ fn aiur_fn_1(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(7);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -1154,14 +1547,14 @@ fn aiur_fn_1(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(6);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -1170,14 +1563,14 @@ fn aiur_fn_1(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(7);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -1198,14 +1591,14 @@ fn aiur_fn_1(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(4);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -1214,14 +1607,14 @@ fn aiur_fn_1(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(7);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -1234,14 +1627,14 @@ fn aiur_fn_1(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(6);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -1250,14 +1643,14 @@ fn aiur_fn_1(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(7);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -1274,14 +1667,14 @@ fn aiur_fn_1(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(5);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -1290,14 +1683,14 @@ fn aiur_fn_1(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(7);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -1310,14 +1703,14 @@ fn aiur_fn_1(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(6);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -1326,14 +1719,14 @@ fn aiur_fn_1(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(7);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_3] = [__v_8];
+                                record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -1352,15 +1745,15 @@ fn aiur_fn_1(
   })
 }
 
-const INPUT_SIZE_2: usize = 8;
-const IN_2: usize = 8;
-const OUT_2: usize = 1;
-fn aiur_fn_2(
-  inp: [G; IN_2],
+const INPUT_SIZE_4: usize = 8;
+const IN_4: usize = 8;
+const OUT_4: usize = 1;
+fn aiur_fn_4(
+  inp: [G; IN_4],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_2], ExecError> {
+) -> Result<[G; OUT_4], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -1387,85 +1780,85 @@ fn aiur_fn_2(
                                 match __v_7.as_canonical_u64() {
                                   0u64 => {
                                     let __v_8: G = G::from_u64(1);
-                                    let __ret: [G; OUT_2] = [__v_8];
-                                    record.function_queries[2].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                    let __ret: [G; OUT_4] = [__v_8];
+                                    record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                     return Ok(__ret);
                                   },
                                   _ => {
                                     let __v_8: G = G::from_u64(0);
-                                    let __ret: [G; OUT_2] = [__v_8];
-                                    record.function_queries[2].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                    let __ret: [G; OUT_4] = [__v_8];
+                                    record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                     return Ok(__ret);
                                   },
                                 }
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(0);
-                                let __ret: [G; OUT_2] = [__v_8];
-                                record.function_queries[2].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_4] = [__v_8];
+                                record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
                           },
                           _ => {
                             let __v_8: G = G::from_u64(0);
-                            let __ret: [G; OUT_2] = [__v_8];
-                            record.function_queries[2].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_4] = [__v_8];
+                            record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                         }
                       },
                       _ => {
                         let __v_8: G = G::from_u64(0);
-                        let __ret: [G; OUT_2] = [__v_8];
-                        record.function_queries[2].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_4] = [__v_8];
+                        record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                     }
                   },
                   _ => {
                     let __v_8: G = G::from_u64(0);
-                    let __ret: [G; OUT_2] = [__v_8];
-                    record.function_queries[2].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_4] = [__v_8];
+                    record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
               },
               _ => {
                 let __v_8: G = G::from_u64(0);
-                let __ret: [G; OUT_2] = [__v_8];
-                record.function_queries[2].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_4] = [__v_8];
+                record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
           _ => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_2] = [__v_8];
-            record.function_queries[2].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_4] = [__v_8];
+            record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
       _ => {
         let __v_8: G = G::from_u64(0);
-        let __ret: [G; OUT_2] = [__v_8];
-        record.function_queries[2].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_4] = [__v_8];
+        record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_3: usize = 8;
-const IN_3: usize = 8;
-const OUT_3: usize = 4;
-fn aiur_fn_3(
-  inp: [G; IN_3],
+const INPUT_SIZE_5: usize = 8;
+const IN_5: usize = 8;
+const OUT_5: usize = 4;
+fn aiur_fn_5(
+  inp: [G; IN_5],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_3], ExecError> {
+) -> Result<[G; OUT_5], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -1498,21 +1891,21 @@ fn aiur_fn_3(
     let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_20, &__v_19) } else { bytes2_add_value(__v_20, __v_19, record) };
     let __v_22: G = __b2_add.0;
     let __v_23: G = __b2_add.1;
-    let __ret: [G; OUT_3] = [__v_8, __v_12, __v_17, __v_22];
-    record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_5] = [__v_8, __v_12, __v_17, __v_22];
+    record.function_queries[5].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_4: usize = 8;
-const IN_4: usize = 8;
-const OUT_4: usize = 4;
-fn aiur_fn_4(
-  inp: [G; IN_4],
+const INPUT_SIZE_6: usize = 8;
+const IN_6: usize = 8;
+const OUT_6: usize = 4;
+fn aiur_fn_6(
+  inp: [G; IN_6],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_4], ExecError> {
+) -> Result<[G; OUT_6], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -1526,61 +1919,61 @@ fn aiur_fn_4(
     let __v_9: G = if unconstrained { Bytes2::xor(&__v_1, &__v_5) } else { bytes2_xor_value(__v_1, __v_5, record) };
     let __v_10: G = if unconstrained { Bytes2::xor(&__v_2, &__v_6) } else { bytes2_xor_value(__v_2, __v_6, record) };
     let __v_11: G = if unconstrained { Bytes2::xor(&__v_3, &__v_7) } else { bytes2_xor_value(__v_3, __v_7, record) };
-    let __ret: [G; OUT_4] = [__v_8, __v_9, __v_10, __v_11];
-    record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_6] = [__v_8, __v_9, __v_10, __v_11];
+    record.function_queries[6].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_5: usize = 4;
-const IN_5: usize = 4;
-const OUT_5: usize = 4;
-fn aiur_fn_5(
-  inp: [G; IN_5],
+const INPUT_SIZE_7: usize = 4;
+const IN_7: usize = 4;
+const OUT_7: usize = 4;
+fn aiur_fn_7(
+  inp: [G; IN_7],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_5], ExecError> {
+) -> Result<[G; OUT_7], 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 __ret: [G; OUT_5] = [__v_2, __v_3, __v_0, __v_1];
-    record.function_queries[5].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_7] = [__v_2, __v_3, __v_0, __v_1];
+    record.function_queries[7].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_6: usize = 4;
-const IN_6: usize = 4;
-const OUT_6: usize = 4;
-fn aiur_fn_6(
-  inp: [G; IN_6],
+const INPUT_SIZE_8: usize = 4;
+const IN_8: usize = 4;
+const OUT_8: usize = 4;
+fn aiur_fn_8(
+  inp: [G; IN_8],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_6], ExecError> {
+) -> Result<[G; OUT_8], 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 __ret: [G; OUT_6] = [__v_1, __v_2, __v_3, __v_0];
-    record.function_queries[6].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_8] = [__v_1, __v_2, __v_3, __v_0];
+    record.function_queries[8].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_7: usize = 4;
-const IN_7: usize = 4;
-const OUT_7: usize = 4;
-fn aiur_fn_7(
-  inp: [G; IN_7],
+const INPUT_SIZE_9: usize = 4;
+const IN_9: usize = 4;
+const OUT_9: usize = 4;
+fn aiur_fn_9(
+  inp: [G; IN_9],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_7], ExecError> {
+) -> Result<[G; OUT_9], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -1596,21 +1989,21 @@ fn aiur_fn_7(
     let __v_9: G = __b2_out.2;
     let __v_10: G = (__v_5 + __v_9);
     let __v_11: G = (__v_8 + __v_6);
-    let __ret: [G; OUT_7] = [__v_4, __v_10, __v_7, __v_11];
-    record.function_queries[7].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_9] = [__v_4, __v_10, __v_7, __v_11];
+    record.function_queries[9].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_8: usize = 4;
-const IN_8: usize = 4;
-const OUT_8: usize = 4;
-fn aiur_fn_8(
-  inp: [G; IN_8],
+const INPUT_SIZE_10: usize = 4;
+const IN_10: usize = 4;
+const OUT_10: usize = 4;
+fn aiur_fn_10(
+  inp: [G; IN_10],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_8], ExecError> {
+) -> Result<[G; OUT_10], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -1626,21 +2019,21 @@ fn aiur_fn_8(
     let __v_9: G = __b2_out.2;
     let __v_10: G = (__v_5 + __v_9);
     let __v_11: G = (__v_8 + __v_6);
-    let __ret: [G; OUT_8] = [__v_4, __v_10, __v_7, __v_11];
-    record.function_queries[8].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_10] = [__v_4, __v_10, __v_7, __v_11];
+    record.function_queries[10].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_9: usize = 16;
-const IN_9: usize = 16;
-const OUT_9: usize = 1;
-fn aiur_fn_9(
-  inp: [G; IN_9],
+const INPUT_SIZE_11: usize = 16;
+const IN_11: usize = 16;
+const OUT_11: usize = 1;
+fn aiur_fn_11(
+  inp: [G; IN_11],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_9], ExecError> {
+) -> Result<[G; OUT_11], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -1683,85 +2076,85 @@ fn aiur_fn_9(
                                 match __v_23.as_canonical_u64() {
                                   0u64 => {
                                     let __v_24: G = G::from_u64(1);
-                                    let __ret: [G; OUT_9] = [__v_24];
-                                    record.function_queries[9].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                    let __ret: [G; OUT_11] = [__v_24];
+                                    record.function_queries[11].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                     return Ok(__ret);
                                   },
                                   _ => {
                                     let __v_24: G = G::from_u64(0);
-                                    let __ret: [G; OUT_9] = [__v_24];
-                                    record.function_queries[9].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                    let __ret: [G; OUT_11] = [__v_24];
+                                    record.function_queries[11].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                     return Ok(__ret);
                                   },
                                 }
                               },
                               _ => {
                                 let __v_24: G = G::from_u64(0);
-                                let __ret: [G; OUT_9] = [__v_24];
-                                record.function_queries[9].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_11] = [__v_24];
+                                record.function_queries[11].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
                           },
                           _ => {
                             let __v_24: G = G::from_u64(0);
-                            let __ret: [G; OUT_9] = [__v_24];
-                            record.function_queries[9].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_11] = [__v_24];
+                            record.function_queries[11].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                         }
                       },
                       _ => {
                         let __v_24: G = G::from_u64(0);
-                        let __ret: [G; OUT_9] = [__v_24];
-                        record.function_queries[9].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_11] = [__v_24];
+                        record.function_queries[11].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                     }
                   },
                   _ => {
                     let __v_24: G = G::from_u64(0);
-                    let __ret: [G; OUT_9] = [__v_24];
-                    record.function_queries[9].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_11] = [__v_24];
+                    record.function_queries[11].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
               },
               _ => {
                 let __v_24: G = G::from_u64(0);
-                let __ret: [G; OUT_9] = [__v_24];
-                record.function_queries[9].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_11] = [__v_24];
+                record.function_queries[11].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
           _ => {
             let __v_24: G = G::from_u64(0);
-            let __ret: [G; OUT_9] = [__v_24];
-            record.function_queries[9].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_11] = [__v_24];
+            record.function_queries[11].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
       _ => {
         let __v_24: G = G::from_u64(0);
-        let __ret: [G; OUT_9] = [__v_24];
-        record.function_queries[9].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_11] = [__v_24];
+        record.function_queries[11].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_10: usize = 16;
-const IN_10: usize = 16;
-const OUT_10: usize = 9;
-fn aiur_fn_10(
-  inp: [G; IN_10],
+const INPUT_SIZE_12: usize = 16;
+const IN_12: usize = 16;
+const OUT_12: usize = 9;
+fn aiur_fn_12(
+  inp: [G; IN_12],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_10], ExecError> {
+) -> Result<[G; OUT_12], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -1831,21 +2224,21 @@ fn aiur_fn_10(
     let __v_50: G = __b2_add.0;
     let __v_51: G = __b2_add.1;
     let __v_52: G = (__v_49 + __v_51);
-    let __ret: [G; OUT_10] = [__v_16, __v_20, __v_25, __v_30, __v_35, __v_40, __v_45, __v_50, __v_52];
-    record.function_queries[10].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_12] = [__v_16, __v_20, __v_25, __v_30, __v_35, __v_40, __v_45, __v_50, __v_52];
+    record.function_queries[12].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_11: usize = 8;
-const IN_11: usize = 8;
-const OUT_11: usize = 8;
-fn aiur_fn_11(
-  inp: [G; IN_11],
+const INPUT_SIZE_13: usize = 8;
+const IN_13: usize = 8;
+const OUT_13: usize = 8;
+fn aiur_fn_13(
+  inp: [G; IN_13],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_11], ExecError> {
+) -> Result<[G; OUT_13], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -1879,8 +2272,8 @@ fn aiur_fn_11(
                                     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 __ret: [G; OUT_11] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15];
-                                    record.function_queries[11].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                    let __ret: [G; OUT_13] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15];
+                                    record.function_queries[13].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                     return Ok(__ret);
                                   },
                                   _ => {
@@ -1893,8 +2286,8 @@ fn aiur_fn_11(
                                     let __v_14: G = G::from_u64(0);
                                     let __v_15: G = G::from_u64(1);
                                     let __v_16: G = (__v_7 + __v_15);
-                                    let __ret: [G; OUT_11] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_16];
-                                    record.function_queries[11].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                    let __ret: [G; OUT_13] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_16];
+                                    record.function_queries[13].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                     return Ok(__ret);
                                   },
                                 }
@@ -1908,8 +2301,8 @@ fn aiur_fn_11(
                                 let __v_13: G = G::from_u64(0);
                                 let __v_14: G = G::from_u64(1);
                                 let __v_15: G = (__v_6 + __v_14);
-                                let __ret: [G; OUT_11] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_15, __v_7];
-                                record.function_queries[11].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_13] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_15, __v_7];
+                                record.function_queries[13].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -1922,8 +2315,8 @@ fn aiur_fn_11(
                             let __v_12: G = G::from_u64(0);
                             let __v_13: G = G::from_u64(1);
                             let __v_14: G = (__v_5 + __v_13);
-                            let __ret: [G; OUT_11] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_14, __v_6, __v_7];
-                            record.function_queries[11].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_13] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_14, __v_6, __v_7];
+                            record.function_queries[13].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                         }
@@ -1935,8 +2328,8 @@ fn aiur_fn_11(
                         let __v_11: G = G::from_u64(0);
                         let __v_12: G = G::from_u64(1);
                         let __v_13: G = (__v_4 + __v_12);
-                        let __ret: [G; OUT_11] = [__v_8, __v_9, __v_10, __v_11, __v_13, __v_5, __v_6, __v_7];
-                        record.function_queries[11].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_13] = [__v_8, __v_9, __v_10, __v_11, __v_13, __v_5, __v_6, __v_7];
+                        record.function_queries[13].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                     }
@@ -1947,8 +2340,8 @@ fn aiur_fn_11(
                     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 __ret: [G; OUT_11] = [__v_8, __v_9, __v_10, __v_12, __v_4, __v_5, __v_6, __v_7];
-                    record.function_queries[11].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_13] = [__v_8, __v_9, __v_10, __v_12, __v_4, __v_5, __v_6, __v_7];
+                    record.function_queries[13].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
@@ -1958,8 +2351,8 @@ fn aiur_fn_11(
                 let __v_9: G = G::from_u64(0);
                 let __v_10: G = G::from_u64(1);
                 let __v_11: G = (__v_2 + __v_10);
-                let __ret: [G; OUT_11] = [__v_8, __v_9, __v_11, __v_3, __v_4, __v_5, __v_6, __v_7];
-                record.function_queries[11].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_13] = [__v_8, __v_9, __v_11, __v_3, __v_4, __v_5, __v_6, __v_7];
+                record.function_queries[13].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -1968,8 +2361,8 @@ fn aiur_fn_11(
             let __v_8: G = G::from_u64(0);
             let __v_9: G = G::from_u64(1);
             let __v_10: G = (__v_1 + __v_9);
-            let __ret: [G; OUT_11] = [__v_8, __v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7];
-            record.function_queries[11].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_13] = [__v_8, __v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7];
+            record.function_queries[13].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -1977,23 +2370,23 @@ fn aiur_fn_11(
       _ => {
         let __v_8: G = G::from_u64(1);
         let __v_9: G = (__v_0 + __v_8);
-        let __ret: [G; OUT_11] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7];
-        record.function_queries[11].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_13] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7];
+        record.function_queries[13].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 = 8;
-fn aiur_fn_12(
-  inp: [G; IN_12],
+const INPUT_SIZE_14: usize = 8;
+const IN_14: usize = 8;
+const OUT_14: usize = 8;
+fn aiur_fn_14(
+  inp: [G; IN_14],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_12], ExecError> {
+) -> Result<[G; OUT_14], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -2027,8 +2420,8 @@ fn aiur_fn_12(
                                     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 __ret: [G; OUT_12] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15];
-                                    record.function_queries[12].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                    let __ret: [G; OUT_14] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15];
+                                    record.function_queries[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                     return Ok(__ret);
                                   },
                                   _ => {
@@ -2041,8 +2434,8 @@ fn aiur_fn_12(
                                     let __v_14: G = G::from_u64(255);
                                     let __v_15: G = G::from_u64(1);
                                     let __v_16: G = (__v_7 - __v_15);
-                                    let __ret: [G; OUT_12] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_16];
-                                    record.function_queries[12].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                    let __ret: [G; OUT_14] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_16];
+                                    record.function_queries[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                     return Ok(__ret);
                                   },
                                 }
@@ -2056,8 +2449,8 @@ fn aiur_fn_12(
                                 let __v_13: G = G::from_u64(255);
                                 let __v_14: G = G::from_u64(1);
                                 let __v_15: G = (__v_6 - __v_14);
-                                let __ret: [G; OUT_12] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_15, __v_7];
-                                record.function_queries[12].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_14] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_15, __v_7];
+                                record.function_queries[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -2070,8 +2463,8 @@ fn aiur_fn_12(
                             let __v_12: G = G::from_u64(255);
                             let __v_13: G = G::from_u64(1);
                             let __v_14: G = (__v_5 - __v_13);
-                            let __ret: [G; OUT_12] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_14, __v_6, __v_7];
-                            record.function_queries[12].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_14] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_14, __v_6, __v_7];
+                            record.function_queries[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                         }
@@ -2083,8 +2476,8 @@ fn aiur_fn_12(
                         let __v_11: G = G::from_u64(255);
                         let __v_12: G = G::from_u64(1);
                         let __v_13: G = (__v_4 - __v_12);
-                        let __ret: [G; OUT_12] = [__v_8, __v_9, __v_10, __v_11, __v_13, __v_5, __v_6, __v_7];
-                        record.function_queries[12].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_14] = [__v_8, __v_9, __v_10, __v_11, __v_13, __v_5, __v_6, __v_7];
+                        record.function_queries[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                     }
@@ -2095,8 +2488,8 @@ fn aiur_fn_12(
                     let __v_10: G = G::from_u64(255);
                     let __v_11: G = G::from_u64(1);
                     let __v_12: G = (__v_3 - __v_11);
-                    let __ret: [G; OUT_12] = [__v_8, __v_9, __v_10, __v_12, __v_4, __v_5, __v_6, __v_7];
-                    record.function_queries[12].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_14] = [__v_8, __v_9, __v_10, __v_12, __v_4, __v_5, __v_6, __v_7];
+                    record.function_queries[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
@@ -2106,8 +2499,8 @@ fn aiur_fn_12(
                 let __v_9: G = G::from_u64(255);
                 let __v_10: G = G::from_u64(1);
                 let __v_11: G = (__v_2 - __v_10);
-                let __ret: [G; OUT_12] = [__v_8, __v_9, __v_11, __v_3, __v_4, __v_5, __v_6, __v_7];
-                record.function_queries[12].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_14] = [__v_8, __v_9, __v_11, __v_3, __v_4, __v_5, __v_6, __v_7];
+                record.function_queries[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -2116,8 +2509,8 @@ fn aiur_fn_12(
             let __v_8: G = G::from_u64(255);
             let __v_9: G = G::from_u64(1);
             let __v_10: G = (__v_1 - __v_9);
-            let __ret: [G; OUT_12] = [__v_8, __v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7];
-            record.function_queries[12].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_14] = [__v_8, __v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7];
+            record.function_queries[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -2125,23 +2518,23 @@ fn aiur_fn_12(
       _ => {
         let __v_8: G = G::from_u64(1);
         let __v_9: G = (__v_0 - __v_8);
-        let __ret: [G; OUT_12] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7];
-        record.function_queries[12].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_14] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7];
+        record.function_queries[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_13: usize = 8;
-const IN_13: usize = 8;
-const OUT_13: usize = 1;
-fn aiur_fn_13(
-  inp: [G; IN_13],
+const INPUT_SIZE_15: usize = 8;
+const IN_15: usize = 8;
+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_13], ExecError> {
+) -> Result<[G; OUT_15], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -2153,7 +2546,7 @@ fn aiur_fn_13(
     let __v_7: G = inp[7];
     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() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("u64 -> field: value exceeds 2^56 (top byte must be zero)".to_string()) });
     }
     let __v_9: G = G::from_u64(256);
     let __v_10: G = (__v_9 * __v_1);
@@ -2173,21 +2566,21 @@ fn aiur_fn_13(
     let __v_24: G = (__v_12 + __v_23);
     let __v_25: G = (__v_10 + __v_24);
     let __v_26: G = (__v_0 + __v_25);
-    let __ret: [G; OUT_13] = [__v_26];
-    record.function_queries[13].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_15] = [__v_26];
+    record.function_queries[15].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 = 32;
-fn aiur_fn_14(
-  inp: [G; IN_14],
+const INPUT_SIZE_16: usize = 1;
+const IN_16: usize = 1;
+const OUT_16: usize = 32;
+fn aiur_fn_16(
+  inp: [G; IN_16],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_14], ExecError> {
+) -> Result<[G; OUT_16], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = G::from_u64(103);
@@ -2240,7 +2633,7 @@ fn aiur_fn_14(
     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_19] = { let __args: [G; IN_19] = [__v_0, __v_35, __v_36, __v_37, __v_46, __v_47, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[19].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_19] = unsafe { *(result.output.as_ptr() as *const [G; OUT_19]) }; __ret } else { aiur_fn_19(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_0, __v_35, __v_36, __v_37, __v_46, __v_47, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[21].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_21] = unsafe { *(result.output.as_ptr() as *const [G; OUT_21]) }; __ret } else { aiur_fn_21(__args, record, io_buffer, __cu)? } };
     let __v_51: G = __r_arr[0];
     let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; 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: 34 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr };
     let __v_52: G = __loaded[0];
@@ -2277,7 +2670,7 @@ fn aiur_fn_14(
     let __v_83: G = __loaded[31];
     let __v_84: G = __loaded[32];
     let __v_85: G = __loaded[33];
-    let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__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]; let __cu = unconstrained; if let Some(result) = record.function_queries[18].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_18] = unsafe { *(result.output.as_ptr() as *const [G; OUT_18]) }; __ret } else { aiur_fn_18(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_20] = { let __args: [G; IN_20] = [__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]; let __cu = unconstrained; if let Some(result) = record.function_queries[20].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_20] = unsafe { *(result.output.as_ptr() as *const [G; OUT_20]) }; __ret } else { aiur_fn_20(__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];
@@ -2310,21 +2703,21 @@ fn aiur_fn_14(
     let __v_115: G = __r_arr[29];
     let __v_116: G = __r_arr[30];
     let __v_117: G = __r_arr[31];
-    let __ret: [G; OUT_14] = [__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];
-    record.function_queries[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_16] = [__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];
+    record.function_queries[16].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_15: usize = 33;
-const IN_15: usize = 33;
-const OUT_15: usize = 0;
-fn aiur_fn_15(
-  inp: [G; IN_15],
+const INPUT_SIZE_17: usize = 33;
+const IN_17: usize = 33;
+const OUT_17: usize = 0;
+fn aiur_fn_17(
+  inp: [G; IN_17],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_15], ExecError> {
+) -> 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];
@@ -2359,7 +2752,7 @@ fn aiur_fn_15(
     let __v_30: G = inp[30];
     let __v_31: G = inp[31];
     let __v_32: G = inp[32];
-    let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } else { aiur_fn_16(__args, record, io_buffer, __cu)? } };
     let __v_33: G = __r_arr[0];
     let __v_34: G = __r_arr[1];
     let __v_35: G = __r_arr[2];
@@ -2393,119 +2786,119 @@ fn aiur_fn_15(
     let __v_63: G = __r_arr[30];
     let __v_64: G = __r_arr[31];
     if (__v_33 != __v_1) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_33.as_canonical_u64(), rhs: __v_1.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_33.as_canonical_u64(), rhs: __v_1.as_canonical_u64(), msg: Some("blake3 of the supplied bytes != the address they were fetched under".to_string()) });
     }
     if (__v_34 != __v_2) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_34.as_canonical_u64(), rhs: __v_2.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_34.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("blake3 of the supplied bytes != the address they were fetched under".to_string()) });
     }
     if (__v_35 != __v_3) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_35.as_canonical_u64(), rhs: __v_3.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_35.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: Some("blake3 of the supplied bytes != the address they were fetched under".to_string()) });
     }
     if (__v_36 != __v_4) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_36.as_canonical_u64(), rhs: __v_4.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_36.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("blake3 of the supplied bytes != the address they were fetched under".to_string()) });
     }
     if (__v_37 != __v_5) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_37.as_canonical_u64(), rhs: __v_5.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_37.as_canonical_u64(), rhs: __v_5.as_canonical_u64(), msg: Some("blake3 of the supplied bytes != the address they were fetched under".to_string()) });
     }
     if (__v_38 != __v_6) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_38.as_canonical_u64(), rhs: __v_6.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_38.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: Some("blake3 of the supplied bytes != the address they were fetched under".to_string()) });
     }
     if (__v_39 != __v_7) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_39.as_canonical_u64(), rhs: __v_7.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_39.as_canonical_u64(), rhs: __v_7.as_canonical_u64(), msg: Some("blake3 of the supplied bytes != the address they were fetched under".to_string()) });
     }
     if (__v_40 != __v_8) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_40.as_canonical_u64(), rhs: __v_8.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_40.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("blake3 of the supplied bytes != the address they were fetched under".to_string()) });
     }
     if (__v_41 != __v_9) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_41.as_canonical_u64(), rhs: __v_9.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_41.as_canonical_u64(), rhs: __v_9.as_canonical_u64(), msg: Some("blake3 of the supplied bytes != the address they were fetched under".to_string()) });
     }
     if (__v_42 != __v_10) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_42.as_canonical_u64(), rhs: __v_10.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_42.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: Some("blake3 of the supplied bytes != the address they were fetched under".to_string()) });
     }
     if (__v_43 != __v_11) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_43.as_canonical_u64(), rhs: __v_11.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_43.as_canonical_u64(), rhs: __v_11.as_canonical_u64(), msg: Some("blake3 of the supplied bytes != the address they were fetched under".to_string()) });
     }
     if (__v_44 != __v_12) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_44.as_canonical_u64(), rhs: __v_12.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_44.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: Some("blake3 of the supplied bytes != the address they were fetched under".to_string()) });
     }
     if (__v_45 != __v_13) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_45.as_canonical_u64(), rhs: __v_13.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_45.as_canonical_u64(), rhs: __v_13.as_canonical_u64(), msg: Some("blake3 of the supplied bytes != the address they were fetched under".to_string()) });
     }
     if (__v_46 != __v_14) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_46.as_canonical_u64(), rhs: __v_14.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_46.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: Some("blake3 of the supplied bytes != the address they were fetched under".to_string()) });
     }
     if (__v_47 != __v_15) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_47.as_canonical_u64(), rhs: __v_15.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_47.as_canonical_u64(), rhs: __v_15.as_canonical_u64(), msg: Some("blake3 of the supplied bytes != the address they were fetched under".to_string()) });
     }
     if (__v_48 != __v_16) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_48.as_canonical_u64(), rhs: __v_16.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_48.as_canonical_u64(), rhs: __v_16.as_canonical_u64(), msg: Some("blake3 of the supplied bytes != the address they were fetched under".to_string()) });
     }
     if (__v_49 != __v_17) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_49.as_canonical_u64(), rhs: __v_17.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_49.as_canonical_u64(), rhs: __v_17.as_canonical_u64(), msg: Some("blake3 of the supplied bytes != the address they were fetched under".to_string()) });
     }
     if (__v_50 != __v_18) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_50.as_canonical_u64(), rhs: __v_18.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_50.as_canonical_u64(), rhs: __v_18.as_canonical_u64(), msg: Some("blake3 of the supplied bytes != the address they were fetched under".to_string()) });
     }
     if (__v_51 != __v_19) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_51.as_canonical_u64(), rhs: __v_19.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_51.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: Some("blake3 of the supplied bytes != the address they were fetched under".to_string()) });
     }
     if (__v_52 != __v_20) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_52.as_canonical_u64(), rhs: __v_20.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_52.as_canonical_u64(), rhs: __v_20.as_canonical_u64(), msg: Some("blake3 of the supplied bytes != the address they were fetched under".to_string()) });
     }
     if (__v_53 != __v_21) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_53.as_canonical_u64(), rhs: __v_21.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_53.as_canonical_u64(), rhs: __v_21.as_canonical_u64(), msg: Some("blake3 of the supplied bytes != the address they were fetched under".to_string()) });
     }
     if (__v_54 != __v_22) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_54.as_canonical_u64(), rhs: __v_22.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_54.as_canonical_u64(), rhs: __v_22.as_canonical_u64(), msg: Some("blake3 of the supplied bytes != the address they were fetched under".to_string()) });
     }
     if (__v_55 != __v_23) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_55.as_canonical_u64(), rhs: __v_23.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_55.as_canonical_u64(), rhs: __v_23.as_canonical_u64(), msg: Some("blake3 of the supplied bytes != the address they were fetched under".to_string()) });
     }
     if (__v_56 != __v_24) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_56.as_canonical_u64(), rhs: __v_24.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_56.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: Some("blake3 of the supplied bytes != the address they were fetched under".to_string()) });
     }
     if (__v_57 != __v_25) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_57.as_canonical_u64(), rhs: __v_25.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_57.as_canonical_u64(), rhs: __v_25.as_canonical_u64(), msg: Some("blake3 of the supplied bytes != the address they were fetched under".to_string()) });
     }
     if (__v_58 != __v_26) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_58.as_canonical_u64(), rhs: __v_26.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_58.as_canonical_u64(), rhs: __v_26.as_canonical_u64(), msg: Some("blake3 of the supplied bytes != the address they were fetched under".to_string()) });
     }
     if (__v_59 != __v_27) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_59.as_canonical_u64(), rhs: __v_27.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_59.as_canonical_u64(), rhs: __v_27.as_canonical_u64(), msg: Some("blake3 of the supplied bytes != the address they were fetched under".to_string()) });
     }
     if (__v_60 != __v_28) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_60.as_canonical_u64(), rhs: __v_28.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_60.as_canonical_u64(), rhs: __v_28.as_canonical_u64(), msg: Some("blake3 of the supplied bytes != the address they were fetched under".to_string()) });
     }
     if (__v_61 != __v_29) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_61.as_canonical_u64(), rhs: __v_29.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_61.as_canonical_u64(), rhs: __v_29.as_canonical_u64(), msg: Some("blake3 of the supplied bytes != the address they were fetched under".to_string()) });
     }
     if (__v_62 != __v_30) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_62.as_canonical_u64(), rhs: __v_30.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_62.as_canonical_u64(), rhs: __v_30.as_canonical_u64(), msg: Some("blake3 of the supplied bytes != the address they were fetched under".to_string()) });
     }
     if (__v_63 != __v_31) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_63.as_canonical_u64(), rhs: __v_31.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_63.as_canonical_u64(), rhs: __v_31.as_canonical_u64(), msg: Some("blake3 of the supplied bytes != the address they were fetched under".to_string()) });
     }
     if (__v_64 != __v_32) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_64.as_canonical_u64(), rhs: __v_32.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_64.as_canonical_u64(), rhs: __v_32.as_canonical_u64(), msg: Some("blake3 of the supplied bytes != the address they were fetched under".to_string()) });
     }
-    let __ret: [G; OUT_15] = [];
-    record.function_queries[15].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_17] = [];
+    record.function_queries[17].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_16: usize = 1;
-const IN_16: usize = 1;
-const OUT_16: usize = 1;
-fn aiur_fn_16(
-  inp: [G; IN_16],
+const INPUT_SIZE_18: usize = 1;
+const IN_18: usize = 1;
+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_16], ExecError> {
+) -> Result<[G; OUT_18], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } else { aiur_fn_16(__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];
@@ -2539,21 +2932,21 @@ fn aiur_fn_16(
     let __v_31: G = __r_arr[30];
     let __v_32: G = __r_arr[31];
     let __v_33: 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 __ret: [G; OUT_16] = [__v_33];
-    record.function_queries[16].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_18] = [__v_33];
+    record.function_queries[18].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_17: usize = 67;
-const IN_17: usize = 67;
-const OUT_17: usize = 67;
-fn aiur_fn_17(
-  inp: [G; IN_17],
+const INPUT_SIZE_19: usize = 67;
+const IN_19: usize = 67;
+const OUT_19: usize = 67;
+fn aiur_fn_19(
+  inp: [G; IN_19],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_17], ExecError> {
+) -> Result<[G; OUT_19], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -2627,8 +3020,8 @@ fn aiur_fn_17(
         let __v_67: G = G::from_u64(1);
         let __v_68: G = G::from_u64(1);
         let __v_69: G = G::from_u64(1);
-        let __ret: [G; OUT_17] = [__v_67, __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_68, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69];
-        record.function_queries[17].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_19] = [__v_67, __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_68, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69];
+        record.function_queries[19].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -2668,7 +3061,7 @@ fn aiur_fn_17(
         let __v_99: G = __loaded[32];
         let __v_100: G = __loaded[33];
         let __v_101: G = G::from_u64(0);
-        let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__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_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_101]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } else { aiur_fn_17(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_19] = { let __args: [G; IN_19] = [__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_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_101]; let __cu = unconstrained; if let Some(result) = record.function_queries[19].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_19] = unsafe { *(result.output.as_ptr() as *const [G; OUT_19]) }; __ret } else { aiur_fn_19(__args, record, io_buffer, __cu)? } };
         let __v_102: G = __r_arr[0];
         let __v_103: G = __r_arr[1];
         let __v_104: G = __r_arr[2];
@@ -2739,8 +3132,8 @@ fn aiur_fn_17(
         match __v_102.as_canonical_u64() {
           0u64 => {
             let __v_169: G = G::from_u64(1);
-            let __ret: [G; OUT_17] = [__v_169, __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_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, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168];
-            record.function_queries[17].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_19] = [__v_169, __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_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, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168];
+            record.function_queries[19].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
@@ -2791,7 +3184,7 @@ fn aiur_fn_17(
                 let __v_211: G = G::from_u64(0);
                 let __v_212: G = G::from_u64(0);
                 let __v_213: G = G::from_u64(64);
-                let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__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, __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_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, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __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_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_204]; let __cu = unconstrained; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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_28] = { let __args: [G; IN_28] = [__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, __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_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, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __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_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_204]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } else { aiur_fn_28(__args, record, io_buffer, __cu)? } };
                 let __v_214: G = __r_arr[0];
                 let __v_215: G = __r_arr[1];
                 let __v_216: G = __r_arr[2];
@@ -2828,8 +3221,8 @@ fn aiur_fn_17(
                 let __v_247: G = G::from_u64(0);
                 let __v_248: G = G::from_u64(0);
                 let __v_249: G = { let __values: [G; 34] = [__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, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168]; 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_17] = [__v_246, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_248, __v_249, __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, __v_237, __v_238, __v_239, __v_240, __v_241, __v_242, __v_243, __v_244, __v_245];
-                record.function_queries[17].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_19] = [__v_246, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_248, __v_249, __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, __v_237, __v_238, __v_239, __v_240, __v_241, __v_242, __v_243, __v_244, __v_245];
+                record.function_queries[19].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -2842,7 +3235,7 @@ fn aiur_fn_17(
                 let __v_209: G = G::from_u64(0);
                 let __v_210: G = G::from_u64(0);
                 let __v_211: G = G::from_u64(64);
-                let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__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, __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_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, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __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_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_169]; let __cu = unconstrained; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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_28] = { let __args: [G; IN_28] = [__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, __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_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, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __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_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_169]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } else { aiur_fn_28(__args, record, io_buffer, __cu)? } };
                 let __v_212: G = __r_arr[0];
                 let __v_213: G = __r_arr[1];
                 let __v_214: G = __r_arr[2];
@@ -2879,8 +3272,8 @@ fn aiur_fn_17(
                 let __v_245: G = G::from_u64(0);
                 let __v_246: G = G::from_u64(0);
                 let __v_247: G = { let __values: [G; 34] = [__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, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168]; 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_17] = [__v_244, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_246, __v_247, __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, __v_237, __v_238, __v_239, __v_240, __v_241, __v_242, __v_243];
-                record.function_queries[17].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_19] = [__v_244, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_246, __v_247, __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, __v_237, __v_238, __v_239, __v_240, __v_241, __v_242, __v_243];
+                record.function_queries[19].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -2897,15 +3290,15 @@ fn aiur_fn_17(
   })
 }
 
-const INPUT_SIZE_18: usize = 34;
-const IN_18: usize = 34;
-const OUT_18: usize = 32;
-fn aiur_fn_18(
-  inp: [G; IN_18],
+const INPUT_SIZE_20: usize = 34;
+const IN_20: usize = 34;
+const OUT_20: usize = 32;
+fn aiur_fn_20(
+  inp: [G; IN_20],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_18], ExecError> {
+) -> 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];
@@ -2980,8 +3373,8 @@ fn aiur_fn_18(
         let __v_67: G = __loaded[33];
         match __v_34.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_18] = [__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];
-            record.function_queries[18].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_20] = [__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];
+            record.function_queries[20].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -3021,7 +3414,7 @@ fn aiur_fn_18(
             let __v_100: G = __loaded[32];
             let __v_101: G = __loaded[33];
             let __v_102: G = G::from_u64(1);
-            let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__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_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_102]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } else { aiur_fn_17(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_19] = { let __args: [G; IN_19] = [__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_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_102]; let __cu = unconstrained; if let Some(result) = record.function_queries[19].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_19] = unsafe { *(result.output.as_ptr() as *const [G; OUT_19]) }; __ret } else { aiur_fn_19(__args, record, io_buffer, __cu)? } };
             let __v_103: G = __r_arr[0];
             let __v_104: G = __r_arr[1];
             let __v_105: G = __r_arr[2];
@@ -3091,7 +3484,7 @@ fn aiur_fn_18(
             let __v_169: G = __r_arr[66];
             match __v_103.as_canonical_u64() {
               0u64 => {
-                let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__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, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169]; let __cu = unconstrained; if let Some(result) = record.function_queries[18].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_18] = unsafe { *(result.output.as_ptr() as *const [G; OUT_18]) }; __ret } else { aiur_fn_18(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_20] = { let __args: [G; IN_20] = [__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, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169]; let __cu = unconstrained; if let Some(result) = record.function_queries[20].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_20] = unsafe { *(result.output.as_ptr() as *const [G; OUT_20]) }; __ret } else { aiur_fn_20(__args, record, io_buffer, __cu)? } };
                 let __v_170: G = __r_arr[0];
                 let __v_171: G = __r_arr[1];
                 let __v_172: G = __r_arr[2];
@@ -3124,14 +3517,14 @@ fn aiur_fn_18(
                 let __v_199: G = __r_arr[29];
                 let __v_200: G = __r_arr[30];
                 let __v_201: G = __r_arr[31];
-                let __ret: [G; OUT_18] = [__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, __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];
-                record.function_queries[18].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_20] = [__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, __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];
+                record.function_queries[20].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               1u64 => {
                 let __v_170: G = G::from_u64(0);
                 let __v_171: G = { let __values: [G; 34] = [__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, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169]; 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_18] = { let __args: [G; IN_18] = [__v_170, __v_171, __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]; let __cu = unconstrained; if let Some(result) = record.function_queries[18].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_18] = unsafe { *(result.output.as_ptr() as *const [G; OUT_18]) }; __ret } else { aiur_fn_18(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_20] = { let __args: [G; IN_20] = [__v_170, __v_171, __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]; let __cu = unconstrained; if let Some(result) = record.function_queries[20].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_20] = unsafe { *(result.output.as_ptr() as *const [G; OUT_20]) }; __ret } else { aiur_fn_20(__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];
@@ -3164,8 +3557,8 @@ fn aiur_fn_18(
                 let __v_201: G = __r_arr[29];
                 let __v_202: G = __r_arr[30];
                 let __v_203: G = __r_arr[31];
-                let __ret: [G; OUT_18] = [__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, __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];
-                record.function_queries[18].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_20] = [__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, __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];
+                record.function_queries[20].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -3182,15 +3575,15 @@ fn aiur_fn_18(
   })
 }
 
-const INPUT_SIZE_19: usize = 7;
-const IN_19: usize = 7;
-const OUT_19: usize = 1;
-fn aiur_fn_19(
-  inp: [G; IN_19],
+const INPUT_SIZE_21: usize = 7;
+const IN_21: usize = 7;
+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_19], ExecError> {
+) -> Result<[G; OUT_21], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -3205,10 +3598,10 @@ fn aiur_fn_19(
     let __v_9: G = __loaded[2];
     match __v_7.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[22].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[24].get_mut(&__args[..]) { 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 __v_10: G = __r_arr[0];
-        let __ret: [G; OUT_19] = [__v_10];
-        record.function_queries[19].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_21] = [__v_10];
+        record.function_queries[21].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -3216,10 +3609,10 @@ fn aiur_fn_19(
         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_23] = { let __args: [G; IN_23] = [__v_9, __v_11, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[23].get_mut(&__args[..]) { 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_25] = { let __args: [G; IN_25] = [__v_9, __v_11, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[25].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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_12: G = __r_arr[0];
-            let __ret: [G; OUT_19] = [__v_12];
-            record.function_queries[19].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_21] = [__v_12];
+            record.function_queries[21].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -3227,10 +3620,10 @@ fn aiur_fn_19(
             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_19] = { let __args: [G; IN_19] = [__v_9, __v_11, __v_13, __v_15, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[19].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_19] = unsafe { *(result.output.as_ptr() as *const [G; OUT_19]) }; __ret } else { aiur_fn_19(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_9, __v_11, __v_13, __v_15, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[21].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_21] = unsafe { *(result.output.as_ptr() as *const [G; OUT_21]) }; __ret } else { aiur_fn_21(__args, record, io_buffer, __cu)? } };
             let __v_16: G = __r_arr[0];
-            let __ret: [G; OUT_19] = [__v_16];
-            record.function_queries[19].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_21] = [__v_16];
+            record.function_queries[21].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -3242,15 +3635,15 @@ fn aiur_fn_19(
   })
 }
 
-const INPUT_SIZE_20: usize = 1;
-const IN_20: usize = 1;
-const OUT_20: usize = 64;
-fn aiur_fn_20(
-  inp: [G; IN_20],
+const INPUT_SIZE_22: usize = 1;
+const IN_22: usize = 1;
+const OUT_22: usize = 64;
+fn aiur_fn_22(
+  inp: [G; IN_22],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_20], ExecError> {
+) -> 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 };
@@ -3637,8 +4030,8 @@ fn aiur_fn_20(
                                                                                                                                                                                                                                                                 let __v_192: G = __loaded[2];
                                                                                                                                                                                                                                                                 match __v_190.as_canonical_u64() {
                                                                                                                                                                                                                                                                   0u64 => {
-                                                                                                                                                                                                                                                                    let __ret: [G; OUT_20] = [__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];
-                                                                                                                                                                                                                                                                    record.function_queries[20].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                                                                                                                                                                    let __ret: [G; OUT_22] = [__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];
+                                                                                                                                                                                                                                                                    record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                                                                                                                                                                                                                                     return Ok(__ret);
                                                                                                                                                                                                                                                                   },
                                                                                                                                                                                                                                                                   _ => {
@@ -3963,22 +4356,22 @@ fn aiur_fn_20(
   })
 }
 
-const INPUT_SIZE_21: usize = 2;
-const IN_21: usize = 2;
-const OUT_21: usize = 1;
-fn aiur_fn_21(
-  inp: [G; IN_21],
+const INPUT_SIZE_23: usize = 2;
+const IN_23: usize = 2;
+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_21], ExecError> {
+) -> 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];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_21] = [__v_0];
-        record.function_queries[21].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_23] = [__v_0];
+        record.function_queries[23].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -3987,25 +4380,25 @@ fn aiur_fn_21(
         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_21] = { let __args: [G; IN_21] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[21].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_21] = unsafe { *(result.output.as_ptr() as *const [G; OUT_21]) }; __ret } else { aiur_fn_21(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_23] = { let __args: [G; IN_23] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[23].get_mut(&__args[..]) { 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_7: G = __r_arr[0];
-        let __ret: [G; OUT_21] = [__v_7];
-        record.function_queries[21].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_23] = [__v_7];
+        record.function_queries[23].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_22: usize = 6;
-const IN_22: usize = 6;
-const OUT_22: usize = 1;
-fn aiur_fn_22(
-  inp: [G; IN_22],
+const INPUT_SIZE_24: usize = 6;
+const IN_24: usize = 6;
+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_22], 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];
@@ -4155,7 +4548,7 @@ fn aiur_fn_22(
                                             let __v_122: G = __loaded[6];
                                             let __v_123: G = __loaded[7];
                                             let __v_124: G = G::from_u64(0);
-                                            let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__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, __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_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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_28] = { let __args: [G; IN_28] = [__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, __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_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } else { aiur_fn_28(__args, record, io_buffer, __cu)? } };
                                             let __v_125: G = __r_arr[0];
                                             let __v_126: G = __r_arr[1];
                                             let __v_127: G = __r_arr[2];
@@ -4189,62 +4582,62 @@ fn aiur_fn_22(
                                             let __v_155: G = __r_arr[30];
                                             let __v_156: G = __r_arr[31];
                                             let __v_157: G = { let __values: [G; 34] = [__v_19, __v_5, __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_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156]; 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_22] = [__v_157];
-                                            record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                            let __ret: [G; OUT_24] = [__v_157];
+                                            record.function_queries[24].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                             return Ok(__ret);
                                           },
                                           _ => {
-                                            let __ret: [G; OUT_22] = [__v_5];
-                                            record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                            let __ret: [G; OUT_24] = [__v_5];
+                                            record.function_queries[24].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                             return Ok(__ret);
                                           },
                                         }
                                       },
                                       _ => {
-                                        let __ret: [G; OUT_22] = [__v_5];
-                                        record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                        let __ret: [G; OUT_24] = [__v_5];
+                                        record.function_queries[24].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                         return Ok(__ret);
                                       },
                                     }
                                   },
                                   _ => {
-                                    let __ret: [G; OUT_22] = [__v_5];
-                                    record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                    let __ret: [G; OUT_24] = [__v_5];
+                                    record.function_queries[24].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                     return Ok(__ret);
                                   },
                                 }
                               },
                               _ => {
-                                let __ret: [G; OUT_22] = [__v_5];
-                                record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_24] = [__v_5];
+                                record.function_queries[24].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
                           },
                           _ => {
-                            let __ret: [G; OUT_22] = [__v_5];
-                            record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_24] = [__v_5];
+                            record.function_queries[24].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                         }
                       },
                       _ => {
-                        let __ret: [G; OUT_22] = [__v_5];
-                        record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_24] = [__v_5];
+                        record.function_queries[24].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                     }
                   },
                   _ => {
-                    let __ret: [G; OUT_22] = [__v_5];
-                    record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_24] = [__v_5];
+                    record.function_queries[24].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
               },
               _ => {
-                let __ret: [G; OUT_22] = [__v_5];
-                record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_24] = [__v_5];
+                record.function_queries[24].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -4285,8 +4678,8 @@ fn aiur_fn_22(
             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_22] = [__v_42];
-            record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_24] = [__v_42];
+            record.function_queries[24].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -4301,7 +4694,7 @@ fn aiur_fn_22(
         let __v_14: G = __loaded[5];
         let __v_15: G = __loaded[6];
         let __v_16: G = __loaded[7];
-        let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__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[2].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__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[4].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } else { aiur_fn_4(__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);
@@ -4311,9 +4704,9 @@ fn aiur_fn_22(
         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_21] = { let __args: [G; IN_21] = [__v_0, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[21].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_21] = unsafe { *(result.output.as_ptr() as *const [G; OUT_21]) }; __ret } else { aiur_fn_21(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_23] = { let __args: [G; IN_23] = [__v_0, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[23].get_mut(&__args[..]) { 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_26: G = __r_arr[0];
-        let __r_arr: [G; OUT_20] = { let __args: [G; IN_20] = [__v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[20].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_20] = unsafe { *(result.output.as_ptr() as *const [G; OUT_20]) }; __ret } else { aiur_fn_20(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[22].get_mut(&__args[..]) { 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_27: G = __r_arr[0];
         let __v_28: G = __r_arr[1];
         let __v_29: G = __r_arr[2];
@@ -4421,7 +4814,7 @@ fn aiur_fn_22(
         let __v_129: G = __loaded[5];
         let __v_130: G = __loaded[6];
         let __v_131: G = __loaded[7];
-        let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__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_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, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_1, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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_28] = { let __args: [G; IN_28] = [__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_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, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_1, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } else { aiur_fn_28(__args, record, io_buffer, __cu)? } };
         let __v_132: G = __r_arr[0];
         let __v_133: G = __r_arr[1];
         let __v_134: G = __r_arr[2];
@@ -4455,23 +4848,23 @@ fn aiur_fn_22(
         let __v_162: G = __r_arr[30];
         let __v_163: G = __r_arr[31];
         let __v_164: G = { let __values: [G; 34] = [__v_91, __v_5, __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, __v_163]; 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_22] = [__v_164];
-        record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_24] = [__v_164];
+        record.function_queries[24].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_23: usize = 6;
-const IN_23: usize = 6;
-const OUT_23: usize = 1;
-fn aiur_fn_23(
-  inp: [G; IN_23],
+const INPUT_SIZE_25: usize = 6;
+const IN_25: usize = 6;
+const OUT_25: usize = 1;
+fn aiur_fn_25(
+  inp: [G; IN_25],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_23], ExecError> {
+) -> Result<[G; OUT_25], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -4482,7 +4875,7 @@ fn aiur_fn_23(
     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_20] = { let __args: [G; IN_20] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[20].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_20] = unsafe { *(result.output.as_ptr() as *const [G; OUT_20]) }; __ret } else { aiur_fn_20(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[22].get_mut(&__args[..]) { 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 __v_11: G = __r_arr[2];
@@ -4549,7 +4942,7 @@ fn aiur_fn_23(
     let __v_72: G = __r_arr[63];
     match __v_2.as_canonical_u64() {
       1023u64 => {
-        let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[789].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_789] = unsafe { *(result.output.as_ptr() as *const [G; OUT_789]) }; __ret } else { aiur_fn_789(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__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];
@@ -4560,7 +4953,7 @@ fn aiur_fn_23(
         let __v_79: G = __loaded[5];
         let __v_80: G = __loaded[6];
         let __v_81: G = __loaded[7];
-        let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__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[2].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__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[4].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } else { aiur_fn_4(__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);
@@ -4641,7 +5034,7 @@ fn aiur_fn_23(
         let __v_157: G = __loaded[6];
         let __v_158: G = __loaded[7];
         let __v_159: G = G::from_u64(64);
-        let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__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_150, __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, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_85]; let __cu = unconstrained; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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_28] = { let __args: [G; IN_28] = [__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_150, __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, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_85]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } else { aiur_fn_28(__args, record, io_buffer, __cu)? } };
         let __v_160: G = __r_arr[0];
         let __v_161: G = __r_arr[1];
         let __v_162: G = __r_arr[2];
@@ -4689,7 +5082,7 @@ fn aiur_fn_23(
         let __v_203: G = __loaded[5];
         let __v_204: G = __loaded[6];
         let __v_205: G = __loaded[7];
-        let __r_arr: [G; OUT_11] = { let __args: [G; IN_11] = [__v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205]; let __cu = unconstrained; if let Some(result) = record.function_queries[11].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_11] = unsafe { *(result.output.as_ptr() as *const [G; OUT_11]) }; __ret } else { aiur_fn_11(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } };
         let __v_206: G = __r_arr[0];
         let __v_207: G = __r_arr[1];
         let __v_208: G = __r_arr[2];
@@ -4700,17 +5093,17 @@ fn aiur_fn_23(
         let __v_213: G = __r_arr[7];
         let __v_214: G = { let __values: [G; 8] = [__v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213]; 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_215: 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_19] = { let __args: [G; IN_19] = [__v_0, __v_195, __v_196, __v_197, __v_214, __v_215, __v_192]; let __cu = unconstrained; if let Some(result) = record.function_queries[19].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_19] = unsafe { *(result.output.as_ptr() as *const [G; OUT_19]) }; __ret } else { aiur_fn_19(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_0, __v_195, __v_196, __v_197, __v_214, __v_215, __v_192]; let __cu = unconstrained; if let Some(result) = record.function_queries[21].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_21] = unsafe { *(result.output.as_ptr() as *const [G; OUT_21]) }; __ret } else { aiur_fn_21(__args, record, io_buffer, __cu)? } };
         let __v_216: G = __r_arr[0];
-        let __ret: [G; OUT_23] = [__v_216];
-        record.function_queries[23].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_25] = [__v_216];
+        record.function_queries[25].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[789].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_789] = unsafe { *(result.output.as_ptr() as *const [G; OUT_789]) }; __ret } else { aiur_fn_789(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__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_789] = { let __args: [G; IN_789] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[789].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_789] = unsafe { *(result.output.as_ptr() as *const [G; OUT_789]) }; __ret } else { aiur_fn_789(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__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];
@@ -4721,7 +5114,7 @@ fn aiur_fn_23(
         let __v_81: G = __loaded[5];
         let __v_82: G = __loaded[6];
         let __v_83: G = __loaded[7];
-        let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__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[2].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__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[4].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } else { aiur_fn_4(__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);
@@ -4774,7 +5167,7 @@ fn aiur_fn_23(
         let __v_131: G = __loaded[6];
         let __v_132: G = __loaded[7];
         let __v_133: G = G::from_u64(64);
-        let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__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_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, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_92]; let __cu = unconstrained; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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_28] = { let __args: [G; IN_28] = [__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_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, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_92]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } else { aiur_fn_28(__args, record, io_buffer, __cu)? } };
         let __v_134: G = __r_arr[0];
         let __v_135: G = __r_arr[1];
         let __v_136: G = __r_arr[2];
@@ -4814,25 +5207,25 @@ fn aiur_fn_23(
         let __v_170: G = G::from_u64(1);
         let __v_171: G = (__v_2 + __v_170);
         let __v_172: G = { let __values: [G; 32] = [__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, __v_163, __v_164, __v_165]; 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_19] = { let __args: [G; IN_19] = [__v_0, __v_168, __v_169, __v_171, __v_3, __v_172, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[19].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_19] = unsafe { *(result.output.as_ptr() as *const [G; OUT_19]) }; __ret } else { aiur_fn_19(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_0, __v_168, __v_169, __v_171, __v_3, __v_172, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[21].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_21] = unsafe { *(result.output.as_ptr() as *const [G; OUT_21]) }; __ret } else { aiur_fn_21(__args, record, io_buffer, __cu)? } };
         let __v_173: G = __r_arr[0];
-        let __ret: [G; OUT_23] = [__v_173];
-        record.function_queries[23].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_25] = [__v_173];
+        record.function_queries[25].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_24: usize = 24;
-const IN_24: usize = 24;
-const OUT_24: usize = 16;
-fn aiur_fn_24(
-  inp: [G; IN_24],
+const INPUT_SIZE_26: usize = 24;
+const IN_26: usize = 24;
+const OUT_26: usize = 16;
+fn aiur_fn_26(
+  inp: [G; IN_26],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_24], 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];
@@ -5032,21 +5425,21 @@ fn aiur_fn_24(
     let __v_149: G = __b2_out.2;
     let __v_150: G = (__v_145 + __v_149);
     let __v_151: G = (__v_148 + __v_146);
-    let __ret: [G; OUT_24] = [__v_104, __v_108, __v_113, __v_118, __v_144, __v_150, __v_147, __v_151, __v_124, __v_128, __v_133, __v_138, __v_121, __v_122, __v_123, __v_120];
-    record.function_queries[24].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_26] = [__v_104, __v_108, __v_113, __v_118, __v_144, __v_150, __v_147, __v_151, __v_124, __v_128, __v_133, __v_138, __v_121, __v_122, __v_123, __v_120];
+    record.function_queries[26].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_25: usize = 128;
-const IN_25: usize = 128;
-const OUT_25: usize = 128;
-fn aiur_fn_25(
-  inp: [G; IN_25],
+const INPUT_SIZE_27: usize = 128;
+const IN_27: usize = 128;
+const OUT_27: usize = 128;
+fn aiur_fn_27(
+  inp: [G; IN_27],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_25], 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];
@@ -5176,7 +5569,7 @@ fn aiur_fn_25(
     let __v_125: G = inp[125];
     let __v_126: G = inp[126];
     let __v_127: G = inp[127];
-    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_0, __v_1, __v_2, __v_3, __v_16, __v_17, __v_18, __v_19, __v_32, __v_33, __v_34, __v_35, __v_48, __v_49, __v_50, __v_51, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71]; let __cu = unconstrained; if let Some(result) = record.function_queries[24].get_mut(&__args[..]) { 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_26] = { let __args: [G; IN_26] = [__v_0, __v_1, __v_2, __v_3, __v_16, __v_17, __v_18, __v_19, __v_32, __v_33, __v_34, __v_35, __v_48, __v_49, __v_50, __v_51, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71]; let __cu = unconstrained; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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_128: G = __r_arr[0];
     let __v_129: G = __r_arr[1];
     let __v_130: G = __r_arr[2];
@@ -5193,7 +5586,7 @@ fn aiur_fn_25(
     let __v_141: G = __r_arr[13];
     let __v_142: G = __r_arr[14];
     let __v_143: G = __r_arr[15];
-    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_4, __v_5, __v_6, __v_7, __v_20, __v_21, __v_22, __v_23, __v_36, __v_37, __v_38, __v_39, __v_52, __v_53, __v_54, __v_55, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79]; let __cu = unconstrained; if let Some(result) = record.function_queries[24].get_mut(&__args[..]) { 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_26] = { let __args: [G; IN_26] = [__v_4, __v_5, __v_6, __v_7, __v_20, __v_21, __v_22, __v_23, __v_36, __v_37, __v_38, __v_39, __v_52, __v_53, __v_54, __v_55, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79]; let __cu = unconstrained; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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_144: G = __r_arr[0];
     let __v_145: G = __r_arr[1];
     let __v_146: G = __r_arr[2];
@@ -5210,7 +5603,7 @@ fn aiur_fn_25(
     let __v_157: G = __r_arr[13];
     let __v_158: G = __r_arr[14];
     let __v_159: G = __r_arr[15];
-    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_8, __v_9, __v_10, __v_11, __v_24, __v_25, __v_26, __v_27, __v_40, __v_41, __v_42, __v_43, __v_56, __v_57, __v_58, __v_59, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87]; let __cu = unconstrained; if let Some(result) = record.function_queries[24].get_mut(&__args[..]) { 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_26] = { let __args: [G; IN_26] = [__v_8, __v_9, __v_10, __v_11, __v_24, __v_25, __v_26, __v_27, __v_40, __v_41, __v_42, __v_43, __v_56, __v_57, __v_58, __v_59, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87]; let __cu = unconstrained; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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_160: G = __r_arr[0];
     let __v_161: G = __r_arr[1];
     let __v_162: G = __r_arr[2];
@@ -5227,7 +5620,7 @@ fn aiur_fn_25(
     let __v_173: G = __r_arr[13];
     let __v_174: G = __r_arr[14];
     let __v_175: G = __r_arr[15];
-    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_12, __v_13, __v_14, __v_15, __v_28, __v_29, __v_30, __v_31, __v_44, __v_45, __v_46, __v_47, __v_60, __v_61, __v_62, __v_63, __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[24].get_mut(&__args[..]) { 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_26] = { let __args: [G; IN_26] = [__v_12, __v_13, __v_14, __v_15, __v_28, __v_29, __v_30, __v_31, __v_44, __v_45, __v_46, __v_47, __v_60, __v_61, __v_62, __v_63, __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[26].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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_176: G = __r_arr[0];
     let __v_177: G = __r_arr[1];
     let __v_178: G = __r_arr[2];
@@ -5244,7 +5637,7 @@ fn aiur_fn_25(
     let __v_189: G = __r_arr[13];
     let __v_190: G = __r_arr[14];
     let __v_191: G = __r_arr[15];
-    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_128, __v_129, __v_130, __v_131, __v_148, __v_149, __v_150, __v_151, __v_168, __v_169, __v_170, __v_171, __v_188, __v_189, __v_190, __v_191, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103]; let __cu = unconstrained; if let Some(result) = record.function_queries[24].get_mut(&__args[..]) { 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_26] = { let __args: [G; IN_26] = [__v_128, __v_129, __v_130, __v_131, __v_148, __v_149, __v_150, __v_151, __v_168, __v_169, __v_170, __v_171, __v_188, __v_189, __v_190, __v_191, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103]; let __cu = unconstrained; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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_192: G = __r_arr[0];
     let __v_193: G = __r_arr[1];
     let __v_194: G = __r_arr[2];
@@ -5261,7 +5654,7 @@ fn aiur_fn_25(
     let __v_205: G = __r_arr[13];
     let __v_206: G = __r_arr[14];
     let __v_207: G = __r_arr[15];
-    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_144, __v_145, __v_146, __v_147, __v_164, __v_165, __v_166, __v_167, __v_184, __v_185, __v_186, __v_187, __v_140, __v_141, __v_142, __v_143, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111]; let __cu = unconstrained; if let Some(result) = record.function_queries[24].get_mut(&__args[..]) { 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_26] = { let __args: [G; IN_26] = [__v_144, __v_145, __v_146, __v_147, __v_164, __v_165, __v_166, __v_167, __v_184, __v_185, __v_186, __v_187, __v_140, __v_141, __v_142, __v_143, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111]; let __cu = unconstrained; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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_208: G = __r_arr[0];
     let __v_209: G = __r_arr[1];
     let __v_210: G = __r_arr[2];
@@ -5278,7 +5671,7 @@ fn aiur_fn_25(
     let __v_221: G = __r_arr[13];
     let __v_222: G = __r_arr[14];
     let __v_223: G = __r_arr[15];
-    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_160, __v_161, __v_162, __v_163, __v_180, __v_181, __v_182, __v_183, __v_136, __v_137, __v_138, __v_139, __v_156, __v_157, __v_158, __v_159, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119]; let __cu = unconstrained; if let Some(result) = record.function_queries[24].get_mut(&__args[..]) { 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_26] = { let __args: [G; IN_26] = [__v_160, __v_161, __v_162, __v_163, __v_180, __v_181, __v_182, __v_183, __v_136, __v_137, __v_138, __v_139, __v_156, __v_157, __v_158, __v_159, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119]; let __cu = unconstrained; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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_224: G = __r_arr[0];
     let __v_225: G = __r_arr[1];
     let __v_226: G = __r_arr[2];
@@ -5295,7 +5688,7 @@ fn aiur_fn_25(
     let __v_237: G = __r_arr[13];
     let __v_238: G = __r_arr[14];
     let __v_239: G = __r_arr[15];
-    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_176, __v_177, __v_178, __v_179, __v_132, __v_133, __v_134, __v_135, __v_152, __v_153, __v_154, __v_155, __v_172, __v_173, __v_174, __v_175, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127]; let __cu = unconstrained; if let Some(result) = record.function_queries[24].get_mut(&__args[..]) { 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_26] = { let __args: [G; IN_26] = [__v_176, __v_177, __v_178, __v_179, __v_132, __v_133, __v_134, __v_135, __v_152, __v_153, __v_154, __v_155, __v_172, __v_173, __v_174, __v_175, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127]; let __cu = unconstrained; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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_240: G = __r_arr[0];
     let __v_241: G = __r_arr[1];
     let __v_242: G = __r_arr[2];
@@ -5312,21 +5705,21 @@ fn aiur_fn_25(
     let __v_253: G = __r_arr[13];
     let __v_254: G = __r_arr[14];
     let __v_255: G = __r_arr[15];
-    let __ret: [G; OUT_25] = [__v_192, __v_193, __v_194, __v_195, __v_208, __v_209, __v_210, __v_211, __v_224, __v_225, __v_226, __v_227, __v_240, __v_241, __v_242, __v_243, __v_244, __v_245, __v_246, __v_247, __v_196, __v_197, __v_198, __v_199, __v_212, __v_213, __v_214, __v_215, __v_228, __v_229, __v_230, __v_231, __v_232, __v_233, __v_234, __v_235, __v_248, __v_249, __v_250, __v_251, __v_200, __v_201, __v_202, __v_203, __v_216, __v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_223, __v_236, __v_237, __v_238, __v_239, __v_252, __v_253, __v_254, __v_255, __v_204, __v_205, __v_206, __v_207, __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];
-    record.function_queries[25].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_27] = [__v_192, __v_193, __v_194, __v_195, __v_208, __v_209, __v_210, __v_211, __v_224, __v_225, __v_226, __v_227, __v_240, __v_241, __v_242, __v_243, __v_244, __v_245, __v_246, __v_247, __v_196, __v_197, __v_198, __v_199, __v_212, __v_213, __v_214, __v_215, __v_228, __v_229, __v_230, __v_231, __v_232, __v_233, __v_234, __v_235, __v_248, __v_249, __v_250, __v_251, __v_200, __v_201, __v_202, __v_203, __v_216, __v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_223, __v_236, __v_237, __v_238, __v_239, __v_252, __v_253, __v_254, __v_255, __v_204, __v_205, __v_206, __v_207, __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];
+    record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_26: usize = 106;
-const IN_26: usize = 106;
-const OUT_26: usize = 32;
-fn aiur_fn_26(
-  inp: [G; IN_26],
+const INPUT_SIZE_28: usize = 106;
+const IN_28: usize = 106;
+const OUT_28: usize = 32;
+fn aiur_fn_28(
+  inp: [G; IN_28],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_26], 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];
@@ -5456,7 +5849,7 @@ fn aiur_fn_26(
     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 __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__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[25].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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 __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__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[27].get_mut(&__args[..]) { 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_128: G = __r_arr[0];
     let __v_129: G = __r_arr[1];
     let __v_130: G = __r_arr[2];
@@ -5585,7 +5978,7 @@ fn aiur_fn_26(
     let __v_253: G = __r_arr[125];
     let __v_254: G = __r_arr[126];
     let __v_255: G = __r_arr[127];
-    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__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_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, __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_200, __v_201, __v_202, __v_203, __v_216, __v_217, __v_218, __v_219, __v_204, __v_205, __v_206, __v_207, __v_232, __v_233, __v_234, __v_235, __v_220, __v_221, __v_222, __v_223, __v_192, __v_193, __v_194, __v_195, __v_208, __v_209, __v_210, __v_211, __v_244, __v_245, __v_246, __v_247, __v_196, __v_197, __v_198, __v_199, __v_236, __v_237, __v_238, __v_239, __v_240, __v_241, __v_242, __v_243, __v_212, __v_213, __v_214, __v_215, __v_228, __v_229, __v_230, __v_231, __v_248, __v_249, __v_250, __v_251, __v_252, __v_253, __v_254, __v_255, __v_224, __v_225, __v_226, __v_227]; let __cu = unconstrained; if let Some(result) = record.function_queries[25].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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 __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__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_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, __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_200, __v_201, __v_202, __v_203, __v_216, __v_217, __v_218, __v_219, __v_204, __v_205, __v_206, __v_207, __v_232, __v_233, __v_234, __v_235, __v_220, __v_221, __v_222, __v_223, __v_192, __v_193, __v_194, __v_195, __v_208, __v_209, __v_210, __v_211, __v_244, __v_245, __v_246, __v_247, __v_196, __v_197, __v_198, __v_199, __v_236, __v_237, __v_238, __v_239, __v_240, __v_241, __v_242, __v_243, __v_212, __v_213, __v_214, __v_215, __v_228, __v_229, __v_230, __v_231, __v_248, __v_249, __v_250, __v_251, __v_252, __v_253, __v_254, __v_255, __v_224, __v_225, __v_226, __v_227]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { 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_256: G = __r_arr[0];
     let __v_257: G = __r_arr[1];
     let __v_258: G = __r_arr[2];
@@ -5714,7 +6107,7 @@ fn aiur_fn_26(
     let __v_381: G = __r_arr[125];
     let __v_382: G = __r_arr[126];
     let __v_383: G = __r_arr[127];
-    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_256, __v_257, __v_258, __v_259, __v_260, __v_261, __v_262, __v_263, __v_264, __v_265, __v_266, __v_267, __v_268, __v_269, __v_270, __v_271, __v_272, __v_273, __v_274, __v_275, __v_276, __v_277, __v_278, __v_279, __v_280, __v_281, __v_282, __v_283, __v_284, __v_285, __v_286, __v_287, __v_288, __v_289, __v_290, __v_291, __v_292, __v_293, __v_294, __v_295, __v_296, __v_297, __v_298, __v_299, __v_300, __v_301, __v_302, __v_303, __v_304, __v_305, __v_306, __v_307, __v_308, __v_309, __v_310, __v_311, __v_312, __v_313, __v_314, __v_315, __v_316, __v_317, __v_318, __v_319, __v_328, __v_329, __v_330, __v_331, __v_344, __v_345, __v_346, __v_347, __v_332, __v_333, __v_334, __v_335, __v_360, __v_361, __v_362, __v_363, __v_348, __v_349, __v_350, __v_351, __v_320, __v_321, __v_322, __v_323, __v_336, __v_337, __v_338, __v_339, __v_372, __v_373, __v_374, __v_375, __v_324, __v_325, __v_326, __v_327, __v_364, __v_365, __v_366, __v_367, __v_368, __v_369, __v_370, __v_371, __v_340, __v_341, __v_342, __v_343, __v_356, __v_357, __v_358, __v_359, __v_376, __v_377, __v_378, __v_379, __v_380, __v_381, __v_382, __v_383, __v_352, __v_353, __v_354, __v_355]; let __cu = unconstrained; if let Some(result) = record.function_queries[25].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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 __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_256, __v_257, __v_258, __v_259, __v_260, __v_261, __v_262, __v_263, __v_264, __v_265, __v_266, __v_267, __v_268, __v_269, __v_270, __v_271, __v_272, __v_273, __v_274, __v_275, __v_276, __v_277, __v_278, __v_279, __v_280, __v_281, __v_282, __v_283, __v_284, __v_285, __v_286, __v_287, __v_288, __v_289, __v_290, __v_291, __v_292, __v_293, __v_294, __v_295, __v_296, __v_297, __v_298, __v_299, __v_300, __v_301, __v_302, __v_303, __v_304, __v_305, __v_306, __v_307, __v_308, __v_309, __v_310, __v_311, __v_312, __v_313, __v_314, __v_315, __v_316, __v_317, __v_318, __v_319, __v_328, __v_329, __v_330, __v_331, __v_344, __v_345, __v_346, __v_347, __v_332, __v_333, __v_334, __v_335, __v_360, __v_361, __v_362, __v_363, __v_348, __v_349, __v_350, __v_351, __v_320, __v_321, __v_322, __v_323, __v_336, __v_337, __v_338, __v_339, __v_372, __v_373, __v_374, __v_375, __v_324, __v_325, __v_326, __v_327, __v_364, __v_365, __v_366, __v_367, __v_368, __v_369, __v_370, __v_371, __v_340, __v_341, __v_342, __v_343, __v_356, __v_357, __v_358, __v_359, __v_376, __v_377, __v_378, __v_379, __v_380, __v_381, __v_382, __v_383, __v_352, __v_353, __v_354, __v_355]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { 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_384: G = __r_arr[0];
     let __v_385: G = __r_arr[1];
     let __v_386: G = __r_arr[2];
@@ -5843,7 +6236,7 @@ fn aiur_fn_26(
     let __v_509: G = __r_arr[125];
     let __v_510: G = __r_arr[126];
     let __v_511: G = __r_arr[127];
-    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_384, __v_385, __v_386, __v_387, __v_388, __v_389, __v_390, __v_391, __v_392, __v_393, __v_394, __v_395, __v_396, __v_397, __v_398, __v_399, __v_400, __v_401, __v_402, __v_403, __v_404, __v_405, __v_406, __v_407, __v_408, __v_409, __v_410, __v_411, __v_412, __v_413, __v_414, __v_415, __v_416, __v_417, __v_418, __v_419, __v_420, __v_421, __v_422, __v_423, __v_424, __v_425, __v_426, __v_427, __v_428, __v_429, __v_430, __v_431, __v_432, __v_433, __v_434, __v_435, __v_436, __v_437, __v_438, __v_439, __v_440, __v_441, __v_442, __v_443, __v_444, __v_445, __v_446, __v_447, __v_456, __v_457, __v_458, __v_459, __v_472, __v_473, __v_474, __v_475, __v_460, __v_461, __v_462, __v_463, __v_488, __v_489, __v_490, __v_491, __v_476, __v_477, __v_478, __v_479, __v_448, __v_449, __v_450, __v_451, __v_464, __v_465, __v_466, __v_467, __v_500, __v_501, __v_502, __v_503, __v_452, __v_453, __v_454, __v_455, __v_492, __v_493, __v_494, __v_495, __v_496, __v_497, __v_498, __v_499, __v_468, __v_469, __v_470, __v_471, __v_484, __v_485, __v_486, __v_487, __v_504, __v_505, __v_506, __v_507, __v_508, __v_509, __v_510, __v_511, __v_480, __v_481, __v_482, __v_483]; let __cu = unconstrained; if let Some(result) = record.function_queries[25].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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 __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_384, __v_385, __v_386, __v_387, __v_388, __v_389, __v_390, __v_391, __v_392, __v_393, __v_394, __v_395, __v_396, __v_397, __v_398, __v_399, __v_400, __v_401, __v_402, __v_403, __v_404, __v_405, __v_406, __v_407, __v_408, __v_409, __v_410, __v_411, __v_412, __v_413, __v_414, __v_415, __v_416, __v_417, __v_418, __v_419, __v_420, __v_421, __v_422, __v_423, __v_424, __v_425, __v_426, __v_427, __v_428, __v_429, __v_430, __v_431, __v_432, __v_433, __v_434, __v_435, __v_436, __v_437, __v_438, __v_439, __v_440, __v_441, __v_442, __v_443, __v_444, __v_445, __v_446, __v_447, __v_456, __v_457, __v_458, __v_459, __v_472, __v_473, __v_474, __v_475, __v_460, __v_461, __v_462, __v_463, __v_488, __v_489, __v_490, __v_491, __v_476, __v_477, __v_478, __v_479, __v_448, __v_449, __v_450, __v_451, __v_464, __v_465, __v_466, __v_467, __v_500, __v_501, __v_502, __v_503, __v_452, __v_453, __v_454, __v_455, __v_492, __v_493, __v_494, __v_495, __v_496, __v_497, __v_498, __v_499, __v_468, __v_469, __v_470, __v_471, __v_484, __v_485, __v_486, __v_487, __v_504, __v_505, __v_506, __v_507, __v_508, __v_509, __v_510, __v_511, __v_480, __v_481, __v_482, __v_483]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { 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_512: G = __r_arr[0];
     let __v_513: G = __r_arr[1];
     let __v_514: G = __r_arr[2];
@@ -5972,7 +6365,7 @@ fn aiur_fn_26(
     let __v_637: G = __r_arr[125];
     let __v_638: G = __r_arr[126];
     let __v_639: G = __r_arr[127];
-    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_512, __v_513, __v_514, __v_515, __v_516, __v_517, __v_518, __v_519, __v_520, __v_521, __v_522, __v_523, __v_524, __v_525, __v_526, __v_527, __v_528, __v_529, __v_530, __v_531, __v_532, __v_533, __v_534, __v_535, __v_536, __v_537, __v_538, __v_539, __v_540, __v_541, __v_542, __v_543, __v_544, __v_545, __v_546, __v_547, __v_548, __v_549, __v_550, __v_551, __v_552, __v_553, __v_554, __v_555, __v_556, __v_557, __v_558, __v_559, __v_560, __v_561, __v_562, __v_563, __v_564, __v_565, __v_566, __v_567, __v_568, __v_569, __v_570, __v_571, __v_572, __v_573, __v_574, __v_575, __v_584, __v_585, __v_586, __v_587, __v_600, __v_601, __v_602, __v_603, __v_588, __v_589, __v_590, __v_591, __v_616, __v_617, __v_618, __v_619, __v_604, __v_605, __v_606, __v_607, __v_576, __v_577, __v_578, __v_579, __v_592, __v_593, __v_594, __v_595, __v_628, __v_629, __v_630, __v_631, __v_580, __v_581, __v_582, __v_583, __v_620, __v_621, __v_622, __v_623, __v_624, __v_625, __v_626, __v_627, __v_596, __v_597, __v_598, __v_599, __v_612, __v_613, __v_614, __v_615, __v_632, __v_633, __v_634, __v_635, __v_636, __v_637, __v_638, __v_639, __v_608, __v_609, __v_610, __v_611]; let __cu = unconstrained; if let Some(result) = record.function_queries[25].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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 __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_512, __v_513, __v_514, __v_515, __v_516, __v_517, __v_518, __v_519, __v_520, __v_521, __v_522, __v_523, __v_524, __v_525, __v_526, __v_527, __v_528, __v_529, __v_530, __v_531, __v_532, __v_533, __v_534, __v_535, __v_536, __v_537, __v_538, __v_539, __v_540, __v_541, __v_542, __v_543, __v_544, __v_545, __v_546, __v_547, __v_548, __v_549, __v_550, __v_551, __v_552, __v_553, __v_554, __v_555, __v_556, __v_557, __v_558, __v_559, __v_560, __v_561, __v_562, __v_563, __v_564, __v_565, __v_566, __v_567, __v_568, __v_569, __v_570, __v_571, __v_572, __v_573, __v_574, __v_575, __v_584, __v_585, __v_586, __v_587, __v_600, __v_601, __v_602, __v_603, __v_588, __v_589, __v_590, __v_591, __v_616, __v_617, __v_618, __v_619, __v_604, __v_605, __v_606, __v_607, __v_576, __v_577, __v_578, __v_579, __v_592, __v_593, __v_594, __v_595, __v_628, __v_629, __v_630, __v_631, __v_580, __v_581, __v_582, __v_583, __v_620, __v_621, __v_622, __v_623, __v_624, __v_625, __v_626, __v_627, __v_596, __v_597, __v_598, __v_599, __v_612, __v_613, __v_614, __v_615, __v_632, __v_633, __v_634, __v_635, __v_636, __v_637, __v_638, __v_639, __v_608, __v_609, __v_610, __v_611]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { 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_640: G = __r_arr[0];
     let __v_641: G = __r_arr[1];
     let __v_642: G = __r_arr[2];
@@ -6101,7 +6494,7 @@ fn aiur_fn_26(
     let __v_765: G = __r_arr[125];
     let __v_766: G = __r_arr[126];
     let __v_767: G = __r_arr[127];
-    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_640, __v_641, __v_642, __v_643, __v_644, __v_645, __v_646, __v_647, __v_648, __v_649, __v_650, __v_651, __v_652, __v_653, __v_654, __v_655, __v_656, __v_657, __v_658, __v_659, __v_660, __v_661, __v_662, __v_663, __v_664, __v_665, __v_666, __v_667, __v_668, __v_669, __v_670, __v_671, __v_672, __v_673, __v_674, __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_712, __v_713, __v_714, __v_715, __v_728, __v_729, __v_730, __v_731, __v_716, __v_717, __v_718, __v_719, __v_744, __v_745, __v_746, __v_747, __v_732, __v_733, __v_734, __v_735, __v_704, __v_705, __v_706, __v_707, __v_720, __v_721, __v_722, __v_723, __v_756, __v_757, __v_758, __v_759, __v_708, __v_709, __v_710, __v_711, __v_748, __v_749, __v_750, __v_751, __v_752, __v_753, __v_754, __v_755, __v_724, __v_725, __v_726, __v_727, __v_740, __v_741, __v_742, __v_743, __v_760, __v_761, __v_762, __v_763, __v_764, __v_765, __v_766, __v_767, __v_736, __v_737, __v_738, __v_739]; let __cu = unconstrained; if let Some(result) = record.function_queries[25].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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 __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_640, __v_641, __v_642, __v_643, __v_644, __v_645, __v_646, __v_647, __v_648, __v_649, __v_650, __v_651, __v_652, __v_653, __v_654, __v_655, __v_656, __v_657, __v_658, __v_659, __v_660, __v_661, __v_662, __v_663, __v_664, __v_665, __v_666, __v_667, __v_668, __v_669, __v_670, __v_671, __v_672, __v_673, __v_674, __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_712, __v_713, __v_714, __v_715, __v_728, __v_729, __v_730, __v_731, __v_716, __v_717, __v_718, __v_719, __v_744, __v_745, __v_746, __v_747, __v_732, __v_733, __v_734, __v_735, __v_704, __v_705, __v_706, __v_707, __v_720, __v_721, __v_722, __v_723, __v_756, __v_757, __v_758, __v_759, __v_708, __v_709, __v_710, __v_711, __v_748, __v_749, __v_750, __v_751, __v_752, __v_753, __v_754, __v_755, __v_724, __v_725, __v_726, __v_727, __v_740, __v_741, __v_742, __v_743, __v_760, __v_761, __v_762, __v_763, __v_764, __v_765, __v_766, __v_767, __v_736, __v_737, __v_738, __v_739]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { 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_768: G = __r_arr[0];
     let __v_769: G = __r_arr[1];
     let __v_770: G = __r_arr[2];
@@ -6230,7 +6623,7 @@ fn aiur_fn_26(
     let __v_893: G = __r_arr[125];
     let __v_894: G = __r_arr[126];
     let __v_895: G = __r_arr[127];
-    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_768, __v_769, __v_770, __v_771, __v_772, __v_773, __v_774, __v_775, __v_776, __v_777, __v_778, __v_779, __v_780, __v_781, __v_782, __v_783, __v_784, __v_785, __v_786, __v_787, __v_788, __v_789, __v_790, __v_791, __v_792, __v_793, __v_794, __v_795, __v_796, __v_797, __v_798, __v_799, __v_800, __v_801, __v_802, __v_803, __v_804, __v_805, __v_806, __v_807, __v_808, __v_809, __v_810, __v_811, __v_812, __v_813, __v_814, __v_815, __v_816, __v_817, __v_818, __v_819, __v_820, __v_821, __v_822, __v_823, __v_824, __v_825, __v_826, __v_827, __v_828, __v_829, __v_830, __v_831, __v_840, __v_841, __v_842, __v_843, __v_856, __v_857, __v_858, __v_859, __v_844, __v_845, __v_846, __v_847, __v_872, __v_873, __v_874, __v_875, __v_860, __v_861, __v_862, __v_863, __v_832, __v_833, __v_834, __v_835, __v_848, __v_849, __v_850, __v_851, __v_884, __v_885, __v_886, __v_887, __v_836, __v_837, __v_838, __v_839, __v_876, __v_877, __v_878, __v_879, __v_880, __v_881, __v_882, __v_883, __v_852, __v_853, __v_854, __v_855, __v_868, __v_869, __v_870, __v_871, __v_888, __v_889, __v_890, __v_891, __v_892, __v_893, __v_894, __v_895, __v_864, __v_865, __v_866, __v_867]; let __cu = unconstrained; if let Some(result) = record.function_queries[25].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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 __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_768, __v_769, __v_770, __v_771, __v_772, __v_773, __v_774, __v_775, __v_776, __v_777, __v_778, __v_779, __v_780, __v_781, __v_782, __v_783, __v_784, __v_785, __v_786, __v_787, __v_788, __v_789, __v_790, __v_791, __v_792, __v_793, __v_794, __v_795, __v_796, __v_797, __v_798, __v_799, __v_800, __v_801, __v_802, __v_803, __v_804, __v_805, __v_806, __v_807, __v_808, __v_809, __v_810, __v_811, __v_812, __v_813, __v_814, __v_815, __v_816, __v_817, __v_818, __v_819, __v_820, __v_821, __v_822, __v_823, __v_824, __v_825, __v_826, __v_827, __v_828, __v_829, __v_830, __v_831, __v_840, __v_841, __v_842, __v_843, __v_856, __v_857, __v_858, __v_859, __v_844, __v_845, __v_846, __v_847, __v_872, __v_873, __v_874, __v_875, __v_860, __v_861, __v_862, __v_863, __v_832, __v_833, __v_834, __v_835, __v_848, __v_849, __v_850, __v_851, __v_884, __v_885, __v_886, __v_887, __v_836, __v_837, __v_838, __v_839, __v_876, __v_877, __v_878, __v_879, __v_880, __v_881, __v_882, __v_883, __v_852, __v_853, __v_854, __v_855, __v_868, __v_869, __v_870, __v_871, __v_888, __v_889, __v_890, __v_891, __v_892, __v_893, __v_894, __v_895, __v_864, __v_865, __v_866, __v_867]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { 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_896: G = __r_arr[0];
     let __v_897: G = __r_arr[1];
     let __v_898: G = __r_arr[2];
@@ -6391,21 +6784,21 @@ fn aiur_fn_26(
     let __v_1053: G = if unconstrained { Bytes2::xor(&__v_925, &__v_957) } else { bytes2_xor_value(__v_925, __v_957, record) };
     let __v_1054: G = if unconstrained { Bytes2::xor(&__v_926, &__v_958) } else { bytes2_xor_value(__v_926, __v_958, record) };
     let __v_1055: G = if unconstrained { Bytes2::xor(&__v_927, &__v_959) } else { bytes2_xor_value(__v_927, __v_959, record) };
-    let __ret: [G; OUT_26] = [__v_1024, __v_1025, __v_1026, __v_1027, __v_1028, __v_1029, __v_1030, __v_1031, __v_1032, __v_1033, __v_1034, __v_1035, __v_1036, __v_1037, __v_1038, __v_1039, __v_1040, __v_1041, __v_1042, __v_1043, __v_1044, __v_1045, __v_1046, __v_1047, __v_1048, __v_1049, __v_1050, __v_1051, __v_1052, __v_1053, __v_1054, __v_1055];
-    record.function_queries[26].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_28] = [__v_1024, __v_1025, __v_1026, __v_1027, __v_1028, __v_1029, __v_1030, __v_1031, __v_1032, __v_1033, __v_1034, __v_1035, __v_1036, __v_1037, __v_1038, __v_1039, __v_1040, __v_1041, __v_1042, __v_1043, __v_1044, __v_1045, __v_1046, __v_1047, __v_1048, __v_1049, __v_1050, __v_1051, __v_1052, __v_1053, __v_1054, __v_1055];
+    record.function_queries[28].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_27: usize = 19;
-const IN_27: usize = 19;
-const OUT_27: usize = 1;
-fn aiur_fn_27(
-  inp: [G; IN_27],
+const INPUT_SIZE_29: usize = 19;
+const IN_29: usize = 19;
+const OUT_29: usize = 1;
+fn aiur_fn_29(
+  inp: [G; IN_29],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_27], 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];
@@ -6429,22 +6822,22 @@ fn aiur_fn_27(
     match __v_0.as_canonical_u64() {
       0u64 => {
         let __v_19: G = G::from_u64(0);
-        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { 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_33] = { let __args: [G; IN_33] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { 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_20: G = __r_arr[0];
-        let __ret: [G; OUT_27] = [__v_20];
-        record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_29] = [__v_20];
+        record.function_queries[29].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
         let __v_19: G = G::from_u64(1);
-        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { 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_33] = { let __args: [G; IN_33] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { 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_20: G = __r_arr[0];
-        let __ret: [G; OUT_27] = [__v_20];
-        record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_29] = [__v_20];
+        record.function_queries[29].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } else { aiur_fn_771(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_705] = { let __args: [G; IN_705] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[705].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_705] = unsafe { *(result.output.as_ptr() as *const [G; OUT_705]) }; __ret } else { aiur_fn_705(__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];
@@ -6454,18 +6847,18 @@ fn aiur_fn_27(
         let __v_25: G = __r_arr[6];
         let __v_26: G = __r_arr[7];
         let __v_27: G = G::from_u64(2);
-        let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_9, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { 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_34] = { let __args: [G; IN_34] = [__v_9, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { 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_28: G = __r_arr[0];
-        let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { 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_29: G = __r_arr[0];
-        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_27, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { 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_33] = { let __args: [G; IN_33] = [__v_27, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { 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_30: G = __r_arr[0];
-        let __ret: [G; OUT_27] = [__v_30];
-        record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_29] = [__v_30];
+        record.function_queries[29].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } else { aiur_fn_771(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_705] = { let __args: [G; IN_705] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[705].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_705] = unsafe { *(result.output.as_ptr() as *const [G; OUT_705]) }; __ret } else { aiur_fn_705(__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];
@@ -6475,14 +6868,14 @@ fn aiur_fn_27(
         let __v_25: G = __r_arr[6];
         let __v_26: G = __r_arr[7];
         let __v_27: G = G::from_u64(3);
-        let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_9, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { 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_34] = { let __args: [G; IN_34] = [__v_9, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { 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_28: G = __r_arr[0];
-        let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { 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_29: G = __r_arr[0];
-        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_27, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { 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_33] = { let __args: [G; IN_33] = [__v_27, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { 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_30: G = __r_arr[0];
-        let __ret: [G; OUT_27] = [__v_30];
-        record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_29] = [__v_30];
+        record.function_queries[29].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       4u64 => {
@@ -6506,34 +6899,34 @@ fn aiur_fn_27(
         let __v_35: G = __loaded[16];
         let __v_36: G = __loaded[17];
         let __v_37: G = G::from_u64(4);
-        let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__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_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { 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_29] = { let __args: [G; IN_29] = [__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_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
         let __v_38: G = __r_arr[0];
-        let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { 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_39: G = __r_arr[0];
-        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_37, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { 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_33] = { let __args: [G; IN_33] = [__v_37, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { 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 __ret: [G; OUT_27] = [__v_40];
-        record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_29] = [__v_40];
+        record.function_queries[29].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       5u64 => {
         let __v_19: G = G::from_u64(5);
-        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { 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_33] = { let __args: [G; IN_33] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { 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_20: G = __r_arr[0];
-        let __ret: [G; OUT_27] = [__v_20];
-        record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_29] = [__v_20];
+        record.function_queries[29].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       6u64 => {
         let __v_19: G = G::from_u64(6);
-        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { 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_33] = { let __args: [G; IN_33] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { 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_20: G = __r_arr[0];
-        let __ret: [G; OUT_27] = [__v_20];
-        record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_29] = [__v_20];
+        record.function_queries[29].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       7u64 => {
-        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_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__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]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { 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_19: G = __r_arr[0];
         let __v_20: G = __r_arr[1];
         let __v_21: G = __r_arr[2];
@@ -6543,16 +6936,16 @@ fn aiur_fn_27(
         let __v_25: G = __r_arr[6];
         let __v_26: G = __r_arr[7];
         let __v_27: G = G::from_u64(7);
-        let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__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]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { 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_38] = { let __args: [G; IN_38] = [__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]; let __cu = unconstrained; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { 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_28: G = __r_arr[0];
-        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_27, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { 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_33] = { let __args: [G; IN_33] = [__v_27, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { 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_29: G = __r_arr[0];
-        let __ret: [G; OUT_27] = [__v_29];
-        record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_29] = [__v_29];
+        record.function_queries[29].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       8u64 => {
-        let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__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]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { 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_36] = { let __args: [G; IN_36] = [__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]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { 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_19: G = __r_arr[0];
         let __v_20: G = __r_arr[1];
         let __v_21: G = __r_arr[2];
@@ -6562,16 +6955,16 @@ fn aiur_fn_27(
         let __v_25: G = __r_arr[6];
         let __v_26: G = __r_arr[7];
         let __v_27: G = G::from_u64(8);
-        let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__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]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__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]; let __cu = unconstrained; if let Some(result) = record.function_queries[39].get_mut(&__args[..]) { 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_28: G = __r_arr[0];
-        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_27, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { 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_33] = { let __args: [G; IN_33] = [__v_27, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { 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_29: G = __r_arr[0];
-        let __ret: [G; OUT_27] = [__v_29];
-        record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_29] = [__v_29];
+        record.function_queries[29].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       9u64 => {
-        let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__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]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__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]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { 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_19: G = __r_arr[0];
         let __v_20: G = __r_arr[1];
         let __v_21: G = __r_arr[2];
@@ -6581,12 +6974,12 @@ fn aiur_fn_27(
         let __v_25: G = __r_arr[6];
         let __v_26: G = __r_arr[7];
         let __v_27: G = G::from_u64(9);
-        let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__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]; let __cu = unconstrained; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__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]; let __cu = unconstrained; if let Some(result) = record.function_queries[40].get_mut(&__args[..]) { 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_28: G = __r_arr[0];
-        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_27, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { 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_33] = { let __args: [G; IN_33] = [__v_27, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { 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_29: G = __r_arr[0];
-        let __ret: [G; OUT_27] = [__v_29];
-        record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_29] = [__v_29];
+        record.function_queries[29].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       10u64 => {
@@ -6648,24 +7041,24 @@ fn aiur_fn_27(
         let __v_71: G = __loaded[16];
         let __v_72: G = __loaded[17];
         let __v_73: G = G::from_u64(10);
-        let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__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_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { 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_29] = { let __args: [G; IN_29] = [__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_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
         let __v_74: G = __r_arr[0];
-        let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__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_74]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { 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_29] = { let __args: [G; IN_29] = [__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_74]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
         let __v_75: G = __r_arr[0];
-        let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__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_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { 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_29] = { let __args: [G; IN_29] = [__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_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
         let __v_76: G = __r_arr[0];
-        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_73, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { 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_33] = { let __args: [G; IN_33] = [__v_73, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { 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_77: G = __r_arr[0];
-        let __ret: [G; OUT_27] = [__v_77];
-        record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_29] = [__v_77];
+        record.function_queries[29].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       11u64 => {
         let __v_19: G = G::from_u64(11);
-        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { 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_33] = { let __args: [G; IN_33] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { 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_20: G = __r_arr[0];
-        let __ret: [G; OUT_27] = [__v_20];
-        record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_29] = [__v_20];
+        record.function_queries[29].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -6675,15 +7068,15 @@ fn aiur_fn_27(
   })
 }
 
-const INPUT_SIZE_28: usize = 10;
-const IN_28: usize = 10;
-const OUT_28: usize = 1;
-fn aiur_fn_28(
-  inp: [G; IN_28],
+const INPUT_SIZE_30: usize = 10;
+const IN_30: usize = 10;
+const OUT_30: usize = 1;
+fn aiur_fn_30(
+  inp: [G; IN_30],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_28], 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];
@@ -6697,8 +7090,8 @@ fn aiur_fn_28(
     let __v_9: G = inp[9];
     match __v_8.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_28] = [__v_9];
-        record.function_queries[28].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_30] = [__v_9];
+        record.function_queries[30].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -6706,26 +7099,26 @@ fn aiur_fn_28(
         let __v_11: G = G::from_u64(0);
         let __v_12: G = G::from_u64(1);
         let __v_13: G = (__v_8 - __v_12);
-        let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_10, __v_13, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } else { aiur_fn_28(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_10, __v_13, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[30].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_30] = unsafe { *(result.output.as_ptr() as *const [G; OUT_30]) }; __ret } else { aiur_fn_30(__args, record, io_buffer, __cu)? } };
         let __v_14: G = __r_arr[0];
         let __v_15: G = { let __values: [G; 3] = [__v_11, __v_0, __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_28] = [__v_15];
-        record.function_queries[28].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_30] = [__v_15];
+        record.function_queries[30].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_29: usize = 9;
-const IN_29: usize = 9;
-const OUT_29: usize = 1;
-fn aiur_fn_29(
-  inp: [G; IN_29],
+const INPUT_SIZE_31: usize = 9;
+const IN_31: usize = 9;
+const OUT_31: usize = 1;
+fn aiur_fn_31(
+  inp: [G; IN_31],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_29], 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];
@@ -6736,7 +7129,7 @@ fn aiur_fn_29(
     let __v_6: G = inp[6];
     let __v_7: G = inp[7];
     let __v_8: G = inp[8];
-    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[3].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_3] = unsafe { *(result.output.as_ptr() as *const [G; OUT_3]) }; __ret } else { aiur_fn_3(__args, record, io_buffer, __cu)? } };
     let __v_9: G = __r_arr[0];
     let __v_10: G = G::from_u64(128);
     let __v_11: G = if unconstrained { Bytes2::less_than(&__v_0, &__v_10) } else { bytes2_less_than_value(__v_0, __v_10, record) };
@@ -6746,8 +7139,8 @@ fn aiur_fn_29(
           1u64 => {
             let __v_12: G = G::from_u64(0);
             let __v_13: G = { let __values: [G; 3] = [__v_12, __v_0, __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_29] = [__v_13];
-            record.function_queries[29].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_31] = [__v_13];
+            record.function_queries[31].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -6756,11 +7149,11 @@ fn aiur_fn_29(
             let __v_14: G = (__v_9 - __v_13);
             let __v_15: G = (__v_12 + __v_14);
             let __v_16: G = G::from_u64(0);
-            let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_9, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } else { aiur_fn_28(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_9, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[30].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_30] = unsafe { *(result.output.as_ptr() as *const [G; OUT_30]) }; __ret } else { aiur_fn_30(__args, record, io_buffer, __cu)? } };
             let __v_17: G = __r_arr[0];
             let __v_18: G = { let __values: [G; 3] = [__v_16, __v_15, __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 __ret: [G; OUT_29] = [__v_18];
-            record.function_queries[29].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_31] = [__v_18];
+            record.function_queries[31].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -6771,26 +7164,26 @@ fn aiur_fn_29(
         let __v_14: G = (__v_9 - __v_13);
         let __v_15: G = (__v_12 + __v_14);
         let __v_16: G = G::from_u64(0);
-        let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_9, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } else { aiur_fn_28(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_9, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[30].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_30] = unsafe { *(result.output.as_ptr() as *const [G; OUT_30]) }; __ret } else { aiur_fn_30(__args, record, io_buffer, __cu)? } };
         let __v_17: G = __r_arr[0];
         let __v_18: G = { let __values: [G; 3] = [__v_16, __v_15, __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 __ret: [G; OUT_29] = [__v_18];
-        record.function_queries[29].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_31] = [__v_18];
+        record.function_queries[31].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_30: usize = 10;
-const IN_30: usize = 10;
-const OUT_30: usize = 1;
-fn aiur_fn_30(
-  inp: [G; IN_30],
+const INPUT_SIZE_32: usize = 10;
+const IN_32: usize = 10;
+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_30], 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];
@@ -6802,7 +7195,7 @@ fn aiur_fn_30(
     let __v_7: G = inp[7];
     let __v_8: G = inp[8];
     let __v_9: G = inp[9];
-    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__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[1].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__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[3].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_3] = unsafe { *(result.output.as_ptr() as *const [G; OUT_3]) }; __ret } else { aiur_fn_3(__args, record, io_buffer, __cu)? } };
     let __v_10: G = __r_arr[0];
     let __v_11: G = G::from_u64(32);
     let __v_12: G = if unconstrained { Bytes2::less_than(&__v_1, &__v_11) } else { bytes2_less_than_value(__v_1, __v_11, record) };
@@ -6815,8 +7208,8 @@ fn aiur_fn_30(
             let __v_15: G = (__v_14 + __v_1);
             let __v_16: G = G::from_u64(0);
             let __v_17: G = { let __values: [G; 3] = [__v_16, __v_15, __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 __ret: [G; OUT_30] = [__v_17];
-            record.function_queries[30].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_32] = [__v_17];
+            record.function_queries[32].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -6828,11 +7221,11 @@ fn aiur_fn_30(
             let __v_18: G = (__v_15 + __v_17);
             let __v_19: G = (__v_14 + __v_18);
             let __v_20: G = G::from_u64(0);
-            let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } else { aiur_fn_28(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[30].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_30] = unsafe { *(result.output.as_ptr() as *const [G; OUT_30]) }; __ret } else { aiur_fn_30(__args, record, io_buffer, __cu)? } };
             let __v_21: G = __r_arr[0];
             let __v_22: G = { let __values: [G; 3] = [__v_20, __v_19, __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 __ret: [G; OUT_30] = [__v_22];
-            record.function_queries[30].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_32] = [__v_22];
+            record.function_queries[32].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -6846,26 +7239,26 @@ fn aiur_fn_30(
         let __v_18: G = (__v_15 + __v_17);
         let __v_19: G = (__v_14 + __v_18);
         let __v_20: G = G::from_u64(0);
-        let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } else { aiur_fn_28(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[30].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_30] = unsafe { *(result.output.as_ptr() as *const [G; OUT_30]) }; __ret } else { aiur_fn_30(__args, record, io_buffer, __cu)? } };
         let __v_21: G = __r_arr[0];
         let __v_22: G = { let __values: [G; 3] = [__v_20, __v_19, __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 __ret: [G; OUT_30] = [__v_22];
-        record.function_queries[30].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_32] = [__v_22];
+        record.function_queries[32].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_31: usize = 10;
-const IN_31: usize = 10;
-const OUT_31: usize = 1;
-fn aiur_fn_31(
-  inp: [G; IN_31],
+const INPUT_SIZE_33: usize = 10;
+const IN_33: usize = 10;
+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_31], ExecError> {
+) -> 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];
@@ -6877,7 +7270,7 @@ fn aiur_fn_31(
     let __v_7: G = inp[7];
     let __v_8: G = inp[8];
     let __v_9: G = inp[9];
-    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__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[1].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__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[3].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_3] = unsafe { *(result.output.as_ptr() as *const [G; OUT_3]) }; __ret } else { aiur_fn_3(__args, record, io_buffer, __cu)? } };
     let __v_10: G = __r_arr[0];
     let __v_11: G = G::from_u64(8);
     let __v_12: G = if unconstrained { Bytes2::less_than(&__v_1, &__v_11) } else { bytes2_less_than_value(__v_1, __v_11, record) };
@@ -6890,8 +7283,8 @@ fn aiur_fn_31(
             let __v_15: G = (__v_14 + __v_1);
             let __v_16: G = G::from_u64(0);
             let __v_17: G = { let __values: [G; 3] = [__v_16, __v_15, __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 __ret: [G; OUT_31] = [__v_17];
-            record.function_queries[31].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_33] = [__v_17];
+            record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -6903,11 +7296,11 @@ fn aiur_fn_31(
             let __v_18: G = (__v_15 + __v_17);
             let __v_19: G = (__v_14 + __v_18);
             let __v_20: G = G::from_u64(0);
-            let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } else { aiur_fn_28(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[30].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_30] = unsafe { *(result.output.as_ptr() as *const [G; OUT_30]) }; __ret } else { aiur_fn_30(__args, record, io_buffer, __cu)? } };
             let __v_21: G = __r_arr[0];
             let __v_22: G = { let __values: [G; 3] = [__v_20, __v_19, __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 __ret: [G; OUT_31] = [__v_22];
-            record.function_queries[31].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_33] = [__v_22];
+            record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -6921,26 +7314,26 @@ fn aiur_fn_31(
         let __v_18: G = (__v_15 + __v_17);
         let __v_19: G = (__v_14 + __v_18);
         let __v_20: G = G::from_u64(0);
-        let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } else { aiur_fn_28(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[30].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_30] = unsafe { *(result.output.as_ptr() as *const [G; OUT_30]) }; __ret } else { aiur_fn_30(__args, record, io_buffer, __cu)? } };
         let __v_21: G = __r_arr[0];
         let __v_22: G = { let __values: [G; 3] = [__v_20, __v_19, __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 __ret: [G; OUT_31] = [__v_22];
-        record.function_queries[31].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_33] = [__v_22];
+        record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_32: usize = 2;
-const IN_32: usize = 2;
-const OUT_32: usize = 1;
-fn aiur_fn_32(
-  inp: [G; IN_32],
+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_32], ExecError> {
+) -> Result<[G; OUT_34], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -6957,17 +7350,17 @@ fn aiur_fn_32(
     let __v_11: G = __loaded[9];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_32] = [__v_1];
-        record.function_queries[32].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_34] = [__v_1];
+        record.function_queries[34].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { 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_34] = { let __args: [G; IN_34] = [__v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { 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_29] = { let __args: [G; IN_29] = [__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[29].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__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[31].get_mut(&__args[..]) { 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_13: G = __r_arr[0];
-        let __ret: [G; OUT_32] = [__v_13];
-        record.function_queries[32].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_34] = [__v_13];
+        record.function_queries[34].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -6977,15 +7370,15 @@ fn aiur_fn_32(
   })
 }
 
-const INPUT_SIZE_33: usize = 18;
-const IN_33: usize = 18;
-const OUT_33: usize = 8;
-fn aiur_fn_33(
-  inp: [G; IN_33],
+const INPUT_SIZE_35: usize = 18;
+const IN_35: usize = 18;
+const OUT_35: usize = 8;
+fn aiur_fn_35(
+  inp: [G; IN_35],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_33], ExecError> {
+) -> Result<[G; OUT_35], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -7026,7 +7419,7 @@ fn aiur_fn_33(
         let __v_33: G = __loaded[15];
         let __v_34: G = __loaded[16];
         let __v_35: G = __loaded[17];
-        let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__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 __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__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 __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { 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_36: G = __r_arr[0];
         let __v_37: G = __r_arr[1];
         let __v_38: G = __r_arr[2];
@@ -7035,7 +7428,7 @@ fn aiur_fn_33(
         let __v_41: G = __r_arr[5];
         let __v_42: G = __r_arr[6];
         let __v_43: G = __r_arr[7];
-        let __r_arr: [G; OUT_11] = { let __args: [G; IN_11] = [__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[11].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_11] = unsafe { *(result.output.as_ptr() as *const [G; OUT_11]) }; __ret } else { aiur_fn_11(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__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[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } };
         let __v_44: G = __r_arr[0];
         let __v_45: G = __r_arr[1];
         let __v_46: G = __r_arr[2];
@@ -7044,8 +7437,8 @@ fn aiur_fn_33(
         let __v_49: G = __r_arr[5];
         let __v_50: G = __r_arr[6];
         let __v_51: G = __r_arr[7];
-        let __ret: [G; OUT_33] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51];
-        record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_35] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51];
+        record.function_queries[35].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -7057,23 +7450,23 @@ fn aiur_fn_33(
         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_33] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25];
-        record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_35] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25];
+        record.function_queries[35].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_34: usize = 18;
-const IN_34: usize = 18;
-const OUT_34: usize = 8;
-fn aiur_fn_34(
-  inp: [G; IN_34],
+const INPUT_SIZE_36: usize = 18;
+const IN_36: usize = 18;
+const OUT_36: usize = 8;
+fn aiur_fn_36(
+  inp: [G; IN_36],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_34], 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];
@@ -7114,7 +7507,7 @@ fn aiur_fn_34(
         let __v_33: G = __loaded[15];
         let __v_34: G = __loaded[16];
         let __v_35: G = __loaded[17];
-        let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__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 __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { 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_36] = { let __args: [G; IN_36] = [__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 __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { 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_36: G = __r_arr[0];
         let __v_37: G = __r_arr[1];
         let __v_38: G = __r_arr[2];
@@ -7123,7 +7516,7 @@ fn aiur_fn_34(
         let __v_41: G = __r_arr[5];
         let __v_42: G = __r_arr[6];
         let __v_43: G = __r_arr[7];
-        let __r_arr: [G; OUT_11] = { let __args: [G; IN_11] = [__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[11].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_11] = unsafe { *(result.output.as_ptr() as *const [G; OUT_11]) }; __ret } else { aiur_fn_11(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__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[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } };
         let __v_44: G = __r_arr[0];
         let __v_45: G = __r_arr[1];
         let __v_46: G = __r_arr[2];
@@ -7132,8 +7525,8 @@ fn aiur_fn_34(
         let __v_49: G = __r_arr[5];
         let __v_50: G = __r_arr[6];
         let __v_51: G = __r_arr[7];
-        let __ret: [G; OUT_34] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51];
-        record.function_queries[34].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_36] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51];
+        record.function_queries[36].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -7145,23 +7538,23 @@ fn aiur_fn_34(
         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_34] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25];
-        record.function_queries[34].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_36] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25];
+        record.function_queries[36].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_35: usize = 18;
-const IN_35: usize = 18;
-const OUT_35: usize = 8;
-fn aiur_fn_35(
-  inp: [G; IN_35],
+const INPUT_SIZE_37: usize = 18;
+const IN_37: usize = 18;
+const OUT_37: usize = 8;
+fn aiur_fn_37(
+  inp: [G; IN_37],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_35], 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];
@@ -7202,7 +7595,7 @@ fn aiur_fn_35(
         let __v_33: G = __loaded[15];
         let __v_34: G = __loaded[16];
         let __v_35: G = __loaded[17];
-        let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__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 __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__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 __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { 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_36: G = __r_arr[0];
         let __v_37: G = __r_arr[1];
         let __v_38: G = __r_arr[2];
@@ -7211,7 +7604,7 @@ fn aiur_fn_35(
         let __v_41: G = __r_arr[5];
         let __v_42: G = __r_arr[6];
         let __v_43: G = __r_arr[7];
-        let __r_arr: [G; OUT_11] = { let __args: [G; IN_11] = [__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[11].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_11] = unsafe { *(result.output.as_ptr() as *const [G; OUT_11]) }; __ret } else { aiur_fn_11(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__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[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } };
         let __v_44: G = __r_arr[0];
         let __v_45: G = __r_arr[1];
         let __v_46: G = __r_arr[2];
@@ -7220,8 +7613,8 @@ fn aiur_fn_35(
         let __v_49: G = __r_arr[5];
         let __v_50: G = __r_arr[6];
         let __v_51: G = __r_arr[7];
-        let __ret: [G; OUT_35] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51];
-        record.function_queries[35].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_37] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51];
+        record.function_queries[37].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -7233,23 +7626,23 @@ fn aiur_fn_35(
         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_35] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25];
-        record.function_queries[35].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_37] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25];
+        record.function_queries[37].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_36: usize = 19;
-const IN_36: usize = 19;
-const OUT_36: usize = 1;
-fn aiur_fn_36(
-  inp: [G; IN_36],
+const INPUT_SIZE_38: usize = 19;
+const IN_38: usize = 19;
+const OUT_38: usize = 1;
+fn aiur_fn_38(
+  inp: [G; IN_38],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_36], ExecError> {
+) -> Result<[G; OUT_38], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -7310,34 +7703,34 @@ fn aiur_fn_36(
         let __v_52: G = __loaded[15];
         let __v_53: G = __loaded[16];
         let __v_54: G = __loaded[17];
-        let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__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_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { 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_29] = { let __args: [G; IN_29] = [__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_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
         let __v_55: G = __r_arr[0];
-        let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__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_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { 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_38] = { let __args: [G; IN_38] = [__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_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { 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_56: G = __r_arr[0];
-        let __ret: [G; OUT_36] = [__v_56];
-        record.function_queries[36].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_38] = [__v_56];
+        record.function_queries[38].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__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]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { 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_29] = { let __args: [G; IN_29] = [__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]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
         let __v_19: G = __r_arr[0];
-        let __ret: [G; OUT_36] = [__v_19];
-        record.function_queries[36].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_38] = [__v_19];
+        record.function_queries[38].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_37: usize = 19;
-const IN_37: usize = 19;
-const OUT_37: usize = 1;
-fn aiur_fn_37(
-  inp: [G; IN_37],
+const INPUT_SIZE_39: usize = 19;
+const IN_39: usize = 19;
+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_37], 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];
@@ -7398,34 +7791,34 @@ fn aiur_fn_37(
         let __v_52: G = __loaded[15];
         let __v_53: G = __loaded[16];
         let __v_54: G = __loaded[17];
-        let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__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_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__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_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[39].get_mut(&__args[..]) { 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_55: G = __r_arr[0];
-        let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__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_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { 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_29] = { let __args: [G; IN_29] = [__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_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
         let __v_56: G = __r_arr[0];
-        let __ret: [G; OUT_37] = [__v_56];
-        record.function_queries[37].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_39] = [__v_56];
+        record.function_queries[39].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__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]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { 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_29] = { let __args: [G; IN_29] = [__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]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
         let __v_19: G = __r_arr[0];
-        let __ret: [G; OUT_37] = [__v_19];
-        record.function_queries[37].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_39] = [__v_19];
+        record.function_queries[39].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_38: usize = 19;
-const IN_38: usize = 19;
-const OUT_38: usize = 1;
-fn aiur_fn_38(
-  inp: [G; IN_38],
+const INPUT_SIZE_40: usize = 19;
+const IN_40: usize = 19;
+const OUT_40: usize = 1;
+fn aiur_fn_40(
+  inp: [G; IN_40],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_38], ExecError> {
+) -> Result<[G; OUT_40], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -7486,34 +7879,34 @@ fn aiur_fn_38(
         let __v_52: G = __loaded[15];
         let __v_53: G = __loaded[16];
         let __v_54: G = __loaded[17];
-        let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__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_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__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_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[40].get_mut(&__args[..]) { 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_55: G = __r_arr[0];
-        let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__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_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { 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_29] = { let __args: [G; IN_29] = [__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_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
         let __v_56: G = __r_arr[0];
-        let __ret: [G; OUT_38] = [__v_56];
-        record.function_queries[38].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_40] = [__v_56];
+        record.function_queries[40].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__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]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { 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_29] = { let __args: [G; IN_29] = [__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]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
         let __v_19: G = __r_arr[0];
-        let __ret: [G; OUT_38] = [__v_19];
-        record.function_queries[38].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_40] = [__v_19];
+        record.function_queries[40].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 = 1;
-fn aiur_fn_39(
-  inp: [G; IN_39],
+const INPUT_SIZE_41: usize = 2;
+const IN_41: usize = 2;
+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_39], ExecError> {
+) -> Result<[G; OUT_41], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -7614,21 +8007,21 @@ fn aiur_fn_39(
     let __v_95: G = { let __values: [G; 3] = [__v_94, __v_3, __v_93]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __v_96: G = G::from_u64(0);
     let __v_97: G = { let __values: [G; 3] = [__v_96, __v_2, __v_95]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_97];
-    record.function_queries[39].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_41] = [__v_97];
+    record.function_queries[41].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_40: usize = 2;
-const IN_40: usize = 2;
-const OUT_40: usize = 1;
-fn aiur_fn_40(
-  inp: [G; IN_40],
+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_40], 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];
@@ -7637,20 +8030,20 @@ fn aiur_fn_40(
         match __v_1.as_canonical_u64() {
           0u64 => {
             let __v_2: G = G::from_u64(0);
-            let __ret: [G; OUT_40] = [__v_2];
-            record.function_queries[40].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_42] = [__v_2];
+            record.function_queries[42].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
             let __v_2: G = G::from_u64(1);
-            let __ret: [G; OUT_40] = [__v_2];
-            record.function_queries[40].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_42] = [__v_2];
+            record.function_queries[42].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           2u64 => {
             let __v_2: G = G::from_u64(2);
-            let __ret: [G; OUT_40] = [__v_2];
-            record.function_queries[40].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_42] = [__v_2];
+            record.function_queries[42].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -7662,20 +8055,20 @@ fn aiur_fn_40(
         match __v_1.as_canonical_u64() {
           0u64 => {
             let __v_2: G = G::from_u64(4);
-            let __ret: [G; OUT_40] = [__v_2];
-            record.function_queries[40].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_42] = [__v_2];
+            record.function_queries[42].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
             let __v_2: G = G::from_u64(5);
-            let __ret: [G; OUT_40] = [__v_2];
-            record.function_queries[40].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_42] = [__v_2];
+            record.function_queries[42].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           2u64 => {
             let __v_2: G = G::from_u64(6);
-            let __ret: [G; OUT_40] = [__v_2];
-            record.function_queries[40].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_42] = [__v_2];
+            record.function_queries[42].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -7687,20 +8080,20 @@ fn aiur_fn_40(
         match __v_1.as_canonical_u64() {
           0u64 => {
             let __v_2: G = G::from_u64(8);
-            let __ret: [G; OUT_40] = [__v_2];
-            record.function_queries[40].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_42] = [__v_2];
+            record.function_queries[42].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
             let __v_2: G = G::from_u64(9);
-            let __ret: [G; OUT_40] = [__v_2];
-            record.function_queries[40].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_42] = [__v_2];
+            record.function_queries[42].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           2u64 => {
             let __v_2: G = G::from_u64(10);
-            let __ret: [G; OUT_40] = [__v_2];
-            record.function_queries[40].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_42] = [__v_2];
+            record.function_queries[42].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -7715,15 +8108,15 @@ fn aiur_fn_40(
   })
 }
 
-const INPUT_SIZE_41: usize = 9;
-const IN_41: usize = 9;
-const OUT_41: usize = 8;
-fn aiur_fn_41(
-  inp: [G; IN_41],
+const INPUT_SIZE_43: usize = 9;
+const IN_43: usize = 9;
+const OUT_43: usize = 8;
+fn aiur_fn_43(
+  inp: [G; IN_43],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_41], ExecError> {
+) -> Result<[G; OUT_43], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -7746,7 +8139,7 @@ fn aiur_fn_41(
         let __v_15: G = __loaded[6];
         let __v_16: G = __loaded[7];
         let __v_17: G = __loaded[8];
-        let __r_arr: [G; OUT_41] = { let __args: [G; IN_41] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[41].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_43] = { let __args: [G; IN_43] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[43].get_mut(&__args[..]) { 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_18: G = __r_arr[0];
         let __v_19: G = __r_arr[1];
         let __v_20: G = __r_arr[2];
@@ -7755,7 +8148,7 @@ fn aiur_fn_41(
         let __v_23: G = __r_arr[5];
         let __v_24: G = __r_arr[6];
         let __v_25: G = __r_arr[7];
-        let __r_arr: [G; OUT_11] = { let __args: [G; IN_11] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[11].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_11] = unsafe { *(result.output.as_ptr() as *const [G; OUT_11]) }; __ret } else { aiur_fn_11(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__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];
@@ -7764,8 +8157,8 @@ fn aiur_fn_41(
         let __v_31: G = __r_arr[5];
         let __v_32: G = __r_arr[6];
         let __v_33: G = __r_arr[7];
-        let __ret: [G; OUT_41] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33];
-        record.function_queries[41].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_43] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33];
+        record.function_queries[43].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -7777,23 +8170,23 @@ fn aiur_fn_41(
         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 __ret: [G; OUT_41] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16];
-        record.function_queries[41].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_43] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16];
+        record.function_queries[43].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_42: usize = 9;
-const IN_42: usize = 9;
-const OUT_42: usize = 9;
-fn aiur_fn_42(
-  inp: [G; IN_42],
+const INPUT_SIZE_44: usize = 9;
+const IN_44: usize = 9;
+const OUT_44: usize = 9;
+fn aiur_fn_44(
+  inp: [G; IN_44],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_42], ExecError> {
+) -> Result<[G; OUT_44], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -7816,7 +8209,7 @@ fn aiur_fn_42(
         let __v_15: G = __loaded[6];
         let __v_16: G = __loaded[7];
         let __v_17: G = __loaded[8];
-        let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[42].get_mut(&__args[..]) { 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_44] = { let __args: [G; IN_44] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[44].get_mut(&__args[..]) { 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_18: G = __r_arr[0];
         let __v_19: G = __r_arr[1];
         let __v_20: G = __r_arr[2];
@@ -7826,28 +8219,28 @@ fn aiur_fn_42(
         let __v_24: G = __r_arr[6];
         let __v_25: G = __r_arr[7];
         let __v_26: G = __r_arr[8];
-        let __ret: [G; OUT_42] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26];
-        record.function_queries[42].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_44] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26];
+        record.function_queries[44].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __ret: [G; OUT_42] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8];
-        record.function_queries[42].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_44] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8];
+        record.function_queries[44].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_43: usize = 10;
-const IN_43: usize = 10;
-const OUT_43: usize = 1;
-fn aiur_fn_43(
-  inp: [G; IN_43],
+const INPUT_SIZE_45: usize = 10;
+const IN_45: usize = 10;
+const OUT_45: usize = 1;
+fn aiur_fn_45(
+  inp: [G; IN_45],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_43], 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];
@@ -7864,12 +8257,12 @@ fn aiur_fn_43(
         let __v_10: G = G::from_u64(0);
         let __v_11: G = G::from_u64(0);
         let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __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 __ret: [G; OUT_43] = [__v_12];
-        record.function_queries[43].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_45] = [__v_12];
+        record.function_queries[45].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
-        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 !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 __r_arr: [G; OUT_43] = { let __args: [G; IN_43] = [__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[43].get_mut(&__args[..]) { 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_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
         let __v_12: G = __r_arr[2];
@@ -7878,7 +8271,7 @@ fn aiur_fn_43(
         let __v_15: G = __r_arr[5];
         let __v_16: G = __r_arr[6];
         let __v_17: G = __r_arr[7];
-        let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__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[42].get_mut(&__args[..]) { 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_44] = { let __args: [G; IN_44] = [__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[44].get_mut(&__args[..]) { 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_18: G = __r_arr[0];
         let __v_19: G = __r_arr[1];
         let __v_20: G = __r_arr[2];
@@ -7889,12 +8282,12 @@ fn aiur_fn_43(
         let __v_25: G = __r_arr[7];
         let __v_26: G = __r_arr[8];
         let __v_27: G = G::from_u64(0);
-        let __r_arr: [G; OUT_43] = { let __args: [G; IN_43] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[43].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[45].get_mut(&__args[..]) { 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_28: G = __r_arr[0];
-        let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_27, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[30].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_30] = unsafe { *(result.output.as_ptr() as *const [G; OUT_30]) }; __ret } else { aiur_fn_30(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_27, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { 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_29: G = __r_arr[0];
-        let __ret: [G; OUT_43] = [__v_29];
-        record.function_queries[43].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_45] = [__v_29];
+        record.function_queries[45].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
@@ -7927,14 +8320,14 @@ fn aiur_fn_43(
         let __v_34: G = G::from_u64(0);
         let __v_35: G = G::from_u64(0);
         let __v_36: G = G::from_u64(0);
-        let __r_arr: [G; OUT_43] = { let __args: [G; IN_43] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[43].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[45].get_mut(&__args[..]) { 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_37: G = __r_arr[0];
-        let __r_arr: [G; OUT_43] = { let __args: [G; IN_43] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[43].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[45].get_mut(&__args[..]) { 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_38: G = __r_arr[0];
-        let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[30].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_30] = unsafe { *(result.output.as_ptr() as *const [G; OUT_30]) }; __ret } else { aiur_fn_30(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { 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_39: G = __r_arr[0];
-        let __ret: [G; OUT_43] = [__v_39];
-        record.function_queries[43].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_45] = [__v_39];
+        record.function_queries[45].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
@@ -7967,22 +8360,22 @@ fn aiur_fn_43(
         let __v_34: G = G::from_u64(0);
         let __v_35: G = G::from_u64(0);
         let __v_36: G = G::from_u64(0);
-        let __r_arr: [G; OUT_43] = { let __args: [G; IN_43] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[43].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[45].get_mut(&__args[..]) { 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_37: G = __r_arr[0];
-        let __r_arr: [G; OUT_43] = { let __args: [G; IN_43] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[43].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[45].get_mut(&__args[..]) { 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_38: G = __r_arr[0];
-        let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[30].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_30] = unsafe { *(result.output.as_ptr() as *const [G; OUT_30]) }; __ret } else { aiur_fn_30(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { 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_39: G = __r_arr[0];
-        let __ret: [G; OUT_43] = [__v_39];
-        record.function_queries[43].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_45] = [__v_39];
+        record.function_queries[45].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       4u64 => {
         let __v_10: G = G::from_u64(3);
-        let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_10, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[30].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_30] = unsafe { *(result.output.as_ptr() as *const [G; OUT_30]) }; __ret } else { aiur_fn_30(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_10, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { 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_11: G = __r_arr[0];
-        let __ret: [G; OUT_43] = [__v_11];
-        record.function_queries[43].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_45] = [__v_11];
+        record.function_queries[45].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -7992,15 +8385,15 @@ fn aiur_fn_43(
   })
 }
 
-const INPUT_SIZE_44: usize = 2;
-const IN_44: usize = 2;
-const OUT_44: usize = 1;
-fn aiur_fn_44(
-  inp: [G; IN_44],
+const INPUT_SIZE_46: usize = 2;
+const IN_46: usize = 2;
+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_44], ExecError> {
+) -> Result<[G; OUT_46], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -8010,8 +8403,8 @@ fn aiur_fn_44(
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_44] = [__v_1];
-        record.function_queries[44].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_46] = [__v_1];
+        record.function_queries[46].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -8034,12 +8427,12 @@ fn aiur_fn_44(
         let __v_20: G = __loaded[15];
         let __v_21: G = __loaded[16];
         let __v_22: G = __loaded[17];
-        let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[44].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[46].get_mut(&__args[..]) { 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_23: G = __r_arr[0];
-        let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__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]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { 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_29] = { let __args: [G; IN_29] = [__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]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
         let __v_24: G = __r_arr[0];
-        let __ret: [G; OUT_44] = [__v_24];
-        record.function_queries[44].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_46] = [__v_24];
+        record.function_queries[46].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -8049,15 +8442,15 @@ fn aiur_fn_44(
   })
 }
 
-const INPUT_SIZE_45: usize = 2;
-const IN_45: usize = 2;
-const OUT_45: usize = 1;
-fn aiur_fn_45(
-  inp: [G; IN_45],
+const INPUT_SIZE_47: usize = 2;
+const IN_47: usize = 2;
+const OUT_47: usize = 1;
+fn aiur_fn_47(
+  inp: [G; IN_47],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_45], ExecError> {
+) -> Result<[G; OUT_47], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -8067,8 +8460,8 @@ fn aiur_fn_45(
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_45] = [__v_1];
-        record.function_queries[45].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_47] = [__v_1];
+        record.function_queries[47].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -8082,12 +8475,12 @@ fn aiur_fn_45(
         let __v_11: G = __loaded[6];
         let __v_12: G = __loaded[7];
         let __v_13: G = __loaded[8];
-        let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[45].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[47].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_47] = unsafe { *(result.output.as_ptr() as *const [G; OUT_47]) }; __ret } else { aiur_fn_47(__args, record, io_buffer, __cu)? } };
         let __v_14: G = __r_arr[0];
-        let __r_arr: [G; OUT_43] = { let __args: [G; IN_43] = [__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[43].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__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[45].get_mut(&__args[..]) { 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_15: G = __r_arr[0];
-        let __ret: [G; OUT_45] = [__v_15];
-        record.function_queries[45].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_47] = [__v_15];
+        record.function_queries[47].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -8097,15 +8490,15 @@ fn aiur_fn_45(
   })
 }
 
-const INPUT_SIZE_46: usize = 2;
-const IN_46: usize = 2;
-const OUT_46: usize = 1;
-fn aiur_fn_46(
-  inp: [G; IN_46],
+const INPUT_SIZE_48: usize = 2;
+const IN_48: usize = 2;
+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_46], 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];
@@ -8115,17 +8508,17 @@ fn aiur_fn_46(
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_46] = [__v_1];
-        record.function_queries[46].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_48] = [__v_1];
+        record.function_queries[48].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[46].get_mut(&__args[..]) { 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_48] = { let __args: [G; IN_48] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[48].get_mut(&__args[..]) { 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_5: G = __r_arr[0];
-        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 !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 __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 !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 __ret: [G; OUT_46] = [__v_6];
-        record.function_queries[46].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_48] = [__v_6];
+        record.function_queries[48].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -8135,15 +8528,15 @@ fn aiur_fn_46(
   })
 }
 
-const INPUT_SIZE_47: usize = 2;
-const IN_47: usize = 2;
-const OUT_47: usize = 1;
-fn aiur_fn_47(
-  inp: [G; IN_47],
+const INPUT_SIZE_49: usize = 2;
+const IN_49: usize = 2;
+const OUT_49: usize = 1;
+fn aiur_fn_49(
+  inp: [G; IN_49],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_47], ExecError> {
+) -> Result<[G; OUT_49], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -8152,32 +8545,32 @@ fn aiur_fn_47(
         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_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_47] = [__v_4];
-        record.function_queries[47].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_49] = [__v_4];
+        record.function_queries[49].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
         let __v_2: G = G::from_u64(0);
         let __v_3: G = G::from_u64(1);
         let __v_4: G = { let __values: [G; 3] = [__v_2, __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 __ret: [G; OUT_47] = [__v_4];
-        record.function_queries[47].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_49] = [__v_4];
+        record.function_queries[49].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
         let __v_2: G = G::from_u64(0);
         let __v_3: G = G::from_u64(2);
         let __v_4: G = { let __values: [G; 3] = [__v_2, __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 __ret: [G; OUT_47] = [__v_4];
-        record.function_queries[47].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_49] = [__v_4];
+        record.function_queries[49].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
         let __v_2: G = G::from_u64(0);
         let __v_3: G = G::from_u64(3);
         let __v_4: G = { let __values: [G; 3] = [__v_2, __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 __ret: [G; OUT_47] = [__v_4];
-        record.function_queries[47].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_49] = [__v_4];
+        record.function_queries[49].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -8187,15 +8580,15 @@ fn aiur_fn_47(
   })
 }
 
-const INPUT_SIZE_48: usize = 13;
-const IN_48: usize = 13;
-const OUT_48: usize = 1;
-fn aiur_fn_48(
-  inp: [G; IN_48],
+const INPUT_SIZE_50: usize = 13;
+const IN_50: usize = 13;
+const OUT_50: usize = 1;
+fn aiur_fn_50(
+  inp: [G; IN_50],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_48], 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];
@@ -8250,33 +8643,33 @@ fn aiur_fn_48(
         let __v_46: G = __loaded[15];
         let __v_47: G = __loaded[16];
         let __v_48: G = __loaded[17];
-        let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[40].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[42].get_mut(&__args[..]) { 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_49: G = __r_arr[0];
         let __v_50: G = G::from_u64(0);
-        let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__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_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { 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_29] = { let __args: [G; IN_29] = [__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_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
         let __v_51: G = __r_arr[0];
-        let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__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_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { 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_29] = { let __args: [G; IN_29] = [__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_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
         let __v_52: G = __r_arr[0];
-        let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { 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_53: G = __r_arr[0];
         let __v_54: G = { let __values: [G; 3] = [__v_50, __v_49, __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 __ret: [G; OUT_48] = [__v_54];
-        record.function_queries[48].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_50] = [__v_54];
+        record.function_queries[50].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_49: usize = 10;
-const IN_49: usize = 10;
-const OUT_49: usize = 1;
-fn aiur_fn_49(
-  inp: [G; IN_49],
+const INPUT_SIZE_51: usize = 10;
+const IN_51: usize = 10;
+const OUT_51: usize = 1;
+fn aiur_fn_51(
+  inp: [G; IN_51],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_49], ExecError> {
+) -> Result<[G; OUT_51], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -8309,27 +8702,27 @@ fn aiur_fn_49(
         let __v_25: G = __loaded[15];
         let __v_26: G = __loaded[16];
         let __v_27: G = __loaded[17];
-        let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__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_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { 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_29] = { let __args: [G; IN_29] = [__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_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
         let __v_28: G = __r_arr[0];
-        let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { 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_29: G = __r_arr[0];
-        let __ret: [G; OUT_49] = [__v_29];
-        record.function_queries[49].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_51] = [__v_29];
+        record.function_queries[51].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_50: usize = 2;
-const IN_50: usize = 2;
-const OUT_50: usize = 1;
-fn aiur_fn_50(
-  inp: [G; IN_50],
+const INPUT_SIZE_52: usize = 2;
+const IN_52: usize = 2;
+const OUT_52: usize = 1;
+fn aiur_fn_52(
+  inp: [G; IN_52],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_50], ExecError> {
+) -> Result<[G; OUT_52], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -8347,17 +8740,17 @@ fn aiur_fn_50(
     let __v_12: G = __loaded[10];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_50] = [__v_1];
-        record.function_queries[50].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_52] = [__v_1];
+        record.function_queries[52].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_12, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[50].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_52] = { let __args: [G; IN_52] = [__v_12, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[52].get_mut(&__args[..]) { 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_13: G = __r_arr[0];
-        let __r_arr: [G; OUT_49] = { let __args: [G; IN_49] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[49].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_49] = unsafe { *(result.output.as_ptr() as *const [G; OUT_49]) }; __ret } else { aiur_fn_49(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_51] = { let __args: [G; IN_51] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[51].get_mut(&__args[..]) { 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_14: G = __r_arr[0];
-        let __ret: [G; OUT_50] = [__v_14];
-        record.function_queries[50].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_52] = [__v_14];
+        record.function_queries[52].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -8367,15 +8760,15 @@ fn aiur_fn_50(
   })
 }
 
-const INPUT_SIZE_51: usize = 45;
-const IN_51: usize = 45;
-const OUT_51: usize = 1;
-fn aiur_fn_51(
-  inp: [G; IN_51],
+const INPUT_SIZE_53: usize = 45;
+const IN_53: usize = 45;
+const OUT_53: usize = 1;
+fn aiur_fn_53(
+  inp: [G; IN_53],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_51], ExecError> {
+) -> Result<[G; OUT_53], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -8446,7 +8839,7 @@ fn aiur_fn_51(
         let __v_63: G = G::from_u64(2);
         let __v_64: G = (__v_63 * __v_1);
         let __v_65: G = (__v_0 + __v_64);
-        let __r_arr: [G; OUT_786] = { let __args: [G; IN_786] = [__v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[786].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_786] = unsafe { *(result.output.as_ptr() as *const [G; OUT_786]) }; __ret } else { aiur_fn_786(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } };
         let __v_66: G = __r_arr[0];
         let __v_67: G = __r_arr[1];
         let __v_68: G = __r_arr[2];
@@ -8456,40 +8849,40 @@ fn aiur_fn_51(
         let __v_72: G = __r_arr[6];
         let __v_73: G = __r_arr[7];
         let __v_74: G = G::from_u64(0);
-        let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_43, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[50].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_52] = { let __args: [G; IN_52] = [__v_43, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[52].get_mut(&__args[..]) { 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_75: G = __r_arr[0];
-        let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { 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_76: G = __r_arr[0];
-        let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__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_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { 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_29] = { let __args: [G; IN_29] = [__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_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
         let __v_77: G = __r_arr[0];
-        let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_77]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_77]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { 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_78: G = __r_arr[0];
-        let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_78]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_78]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { 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_79: G = __r_arr[0];
-        let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_79]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_79]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { 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_80: G = __r_arr[0];
-        let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_80]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_80]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { 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_81: G = __r_arr[0];
-        let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_81]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_81]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { 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_82: G = __r_arr[0];
         let __v_83: G = { let __values: [G; 3] = [__v_74, __v_65, __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 __ret: [G; OUT_51] = [__v_83];
-        record.function_queries[51].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_53] = [__v_83];
+        record.function_queries[53].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_52: usize = 11;
-const IN_52: usize = 11;
-const OUT_52: usize = 1;
-fn aiur_fn_52(
-  inp: [G; IN_52],
+const INPUT_SIZE_54: usize = 11;
+const IN_54: usize = 11;
+const OUT_54: usize = 1;
+fn aiur_fn_54(
+  inp: [G; IN_54],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_52], ExecError> {
+) -> Result<[G; OUT_54], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -8524,28 +8917,28 @@ fn aiur_fn_52(
         let __v_27: G = __loaded[16];
         let __v_28: G = __loaded[17];
         let __v_29: G = G::from_u64(0);
-        let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__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_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { 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_29] = { let __args: [G; IN_29] = [__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_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
         let __v_30: G = __r_arr[0];
-        let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { 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_31: G = __r_arr[0];
         let __v_32: G = { let __values: [G; 3] = [__v_29, __v_0, __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 __ret: [G; OUT_52] = [__v_32];
-        record.function_queries[52].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_54] = [__v_32];
+        record.function_queries[54].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_53: usize = 11;
-const IN_53: usize = 11;
-const OUT_53: usize = 1;
-fn aiur_fn_53(
-  inp: [G; IN_53],
+const INPUT_SIZE_55: usize = 11;
+const IN_55: usize = 11;
+const OUT_55: usize = 1;
+fn aiur_fn_55(
+  inp: [G; IN_55],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_53], ExecError> {
+) -> Result<[G; OUT_55], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -8579,29 +8972,29 @@ fn aiur_fn_53(
         let __v_26: G = __loaded[15];
         let __v_27: G = __loaded[16];
         let __v_28: G = __loaded[17];
-        let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__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_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { 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_29] = { let __args: [G; IN_29] = [__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_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
         let __v_29: G = __r_arr[0];
-        let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { 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_30: G = __r_arr[0];
-        let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_0, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[47].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_47] = unsafe { *(result.output.as_ptr() as *const [G; OUT_47]) }; __ret } else { aiur_fn_47(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_49] = { let __args: [G; IN_49] = [__v_0, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[49].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_49] = unsafe { *(result.output.as_ptr() as *const [G; OUT_49]) }; __ret } else { aiur_fn_49(__args, record, io_buffer, __cu)? } };
         let __v_31: G = __r_arr[0];
-        let __ret: [G; OUT_53] = [__v_31];
-        record.function_queries[53].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_55] = [__v_31];
+        record.function_queries[55].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_54: usize = 35;
-const IN_54: usize = 35;
-const OUT_54: usize = 1;
-fn aiur_fn_54(
-  inp: [G; IN_54],
+const INPUT_SIZE_56: usize = 35;
+const IN_56: usize = 35;
+const OUT_56: usize = 1;
+fn aiur_fn_56(
+  inp: [G; IN_56],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_54], ExecError> {
+) -> Result<[G; OUT_56], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -8660,34 +9053,34 @@ fn aiur_fn_54(
         let __v_51: G = __loaded[16];
         let __v_52: G = __loaded[17];
         let __v_53: G = G::from_u64(0);
-        let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__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_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { 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_29] = { let __args: [G; IN_29] = [__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_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
         let __v_54: G = __r_arr[0];
-        let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { 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_55: G = __r_arr[0];
-        let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { 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_56: G = __r_arr[0];
-        let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { 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_57: G = __r_arr[0];
-        let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_57]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_57]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { 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_58: G = __r_arr[0];
         let __v_59: G = { let __values: [G; 3] = [__v_53, __v_0, __v_58]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_54] = [__v_59];
-        record.function_queries[54].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_56] = [__v_59];
+        record.function_queries[56].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_55: usize = 2;
-const IN_55: usize = 2;
-const OUT_55: usize = 1;
-fn aiur_fn_55(
-  inp: [G; IN_55],
+const INPUT_SIZE_57: usize = 2;
+const IN_57: usize = 2;
+const OUT_57: usize = 1;
+fn aiur_fn_57(
+  inp: [G; IN_57],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_55], ExecError> {
+) -> Result<[G; OUT_57], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -8730,17 +9123,17 @@ fn aiur_fn_55(
     let __v_37: G = __loaded[35];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_55] = [__v_1];
-        record.function_queries[55].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_57] = [__v_1];
+        record.function_queries[57].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_37, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[55].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_57] = { let __args: [G; IN_57] = [__v_37, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[57].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_57] = unsafe { *(result.output.as_ptr() as *const [G; OUT_57]) }; __ret } else { aiur_fn_57(__args, record, io_buffer, __cu)? } };
         let __v_38: G = __r_arr[0];
-        let __r_arr: [G; OUT_54] = { let __args: [G; IN_54] = [__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_35, __v_36, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[54].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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 __r_arr: [G; OUT_56] = { let __args: [G; IN_56] = [__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_35, __v_36, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[56].get_mut(&__args[..]) { 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_39: G = __r_arr[0];
-        let __ret: [G; OUT_55] = [__v_39];
-        record.function_queries[55].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_57] = [__v_39];
+        record.function_queries[57].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -8750,15 +9143,15 @@ fn aiur_fn_55(
   })
 }
 
-const INPUT_SIZE_56: usize = 28;
-const IN_56: usize = 28;
-const OUT_56: usize = 1;
-fn aiur_fn_56(
-  inp: [G; IN_56],
+const INPUT_SIZE_58: usize = 28;
+const IN_58: usize = 28;
+const OUT_58: usize = 1;
+fn aiur_fn_58(
+  inp: [G; IN_58],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_56], ExecError> {
+) -> Result<[G; OUT_58], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -8809,7 +9202,7 @@ fn aiur_fn_56(
         let __v_43: G = __loaded[15];
         let __v_44: G = __loaded[16];
         let __v_45: G = __loaded[17];
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[777].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_777] = unsafe { *(result.output.as_ptr() as *const [G; OUT_777]) }; __ret } else { aiur_fn_777(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[712].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_712] = unsafe { *(result.output.as_ptr() as *const [G; OUT_712]) }; __ret } else { aiur_fn_712(__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];
@@ -8819,36 +9212,36 @@ fn aiur_fn_56(
         let __v_52: G = __r_arr[6];
         let __v_53: G = __r_arr[7];
         let __v_54: G = G::from_u64(0);
-        let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_26, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[55].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_57] = { let __args: [G; IN_57] = [__v_26, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[57].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_57] = unsafe { *(result.output.as_ptr() as *const [G; OUT_57]) }; __ret } else { aiur_fn_57(__args, record, io_buffer, __cu)? } };
         let __v_55: G = __r_arr[0];
-        let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { 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_56: G = __r_arr[0];
-        let __r_arr: [G; OUT_27] = { let __args: [G; IN_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_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { 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_29] = { let __args: [G; IN_29] = [__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_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
         let __v_57: G = __r_arr[0];
-        let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_57]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_57]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { 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_58: G = __r_arr[0];
-        let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { 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_59: G = __r_arr[0];
-        let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_59]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_59]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { 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_60: G = __r_arr[0];
         let __v_61: G = { let __values: [G; 3] = [__v_54, __v_0, __v_60]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_61];
-        record.function_queries[56].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_58] = [__v_61];
+        record.function_queries[58].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_57: usize = 10;
-const IN_57: usize = 10;
-const OUT_57: usize = 1;
-fn aiur_fn_57(
-  inp: [G; IN_57],
+const INPUT_SIZE_59: usize = 10;
+const IN_59: usize = 10;
+const OUT_59: usize = 1;
+fn aiur_fn_59(
+  inp: [G; IN_59],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_57], ExecError> {
+) -> Result<[G; OUT_59], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -8862,27 +9255,27 @@ fn aiur_fn_57(
     let __v_9: G = inp[9];
     match __v_0.as_canonical_u64() {
       _ => {
-        let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[39].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_41] = { let __args: [G; IN_41] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[41].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { 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_11: G = __r_arr[0];
-        let __ret: [G; OUT_57] = [__v_11];
-        record.function_queries[57].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_59] = [__v_11];
+        record.function_queries[59].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_58: usize = 18;
-const IN_58: usize = 18;
-const OUT_58: usize = 1;
-fn aiur_fn_58(
-  inp: [G; IN_58],
+const INPUT_SIZE_60: usize = 18;
+const IN_60: usize = 18;
+const OUT_60: usize = 1;
+fn aiur_fn_60(
+  inp: [G; IN_60],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_58], ExecError> {
+) -> Result<[G; OUT_60], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -8904,29 +9297,29 @@ fn aiur_fn_58(
     let __v_17: G = inp[17];
     match __v_0.as_canonical_u64() {
       _ => {
-        let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[39].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_41] = { let __args: [G; IN_41] = [__v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[41].get_mut(&__args[..]) { 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_18: G = __r_arr[0];
-        let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { 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_19: G = __r_arr[0];
-        let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { 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_20: G = __r_arr[0];
-        let __ret: [G; OUT_58] = [__v_20];
-        record.function_queries[58].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_60] = [__v_20];
+        record.function_queries[60].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_59: usize = 46;
-const IN_59: usize = 46;
-const OUT_59: usize = 1;
-fn aiur_fn_59(
-  inp: [G; IN_59],
+const INPUT_SIZE_61: usize = 46;
+const IN_61: usize = 46;
+const OUT_61: usize = 1;
+fn aiur_fn_61(
+  inp: [G; IN_61],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_59], ExecError> {
+) -> 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];
@@ -8978,31 +9371,31 @@ fn aiur_fn_59(
       0u64 => {
         let __v_46: G = G::from_u64(0);
         let __v_47: G = G::from_u64(0);
-        let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__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_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[48].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__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_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[50].get_mut(&__args[..]) { 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_48: G = __r_arr[0];
         let __v_49: G = { let __values: [G; 3] = [__v_46, __v_47, __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 __ret: [G; OUT_59] = [__v_49];
-        record.function_queries[59].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_61] = [__v_49];
+        record.function_queries[61].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
         let __v_46: G = G::from_u64(0);
         let __v_47: G = G::from_u64(1);
-        let __r_arr: [G; OUT_56] = { let __args: [G; IN_56] = [__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_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[56].get_mut(&__args[..]) { 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_58] = { let __args: [G; IN_58] = [__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_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[58].get_mut(&__args[..]) { 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_48: G = __r_arr[0];
         let __v_49: G = { let __values: [G; 3] = [__v_46, __v_47, __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 __ret: [G; OUT_59] = [__v_49];
-        record.function_queries[59].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_61] = [__v_49];
+        record.function_queries[61].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
         let __v_46: G = G::from_u64(0);
         let __v_47: G = G::from_u64(2);
-        let __r_arr: [G; OUT_51] = { let __args: [G; IN_51] = [__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_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]; let __cu = unconstrained; if let Some(result) = record.function_queries[51].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_53] = { let __args: [G; IN_53] = [__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_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]; let __cu = unconstrained; if let Some(result) = record.function_queries[53].get_mut(&__args[..]) { 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_48: G = __r_arr[0];
         let __v_49: G = { let __values: [G; 3] = [__v_46, __v_47, __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 __ret: [G; OUT_59] = [__v_49];
-        record.function_queries[59].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_61] = [__v_49];
+        record.function_queries[61].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -9012,15 +9405,15 @@ fn aiur_fn_59(
   })
 }
 
-const INPUT_SIZE_60: usize = 2;
-const IN_60: usize = 2;
-const OUT_60: usize = 1;
-fn aiur_fn_60(
-  inp: [G; IN_60],
+const INPUT_SIZE_62: usize = 2;
+const IN_62: usize = 2;
+const OUT_62: usize = 1;
+fn aiur_fn_62(
+  inp: [G; IN_62],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_60], ExecError> {
+) -> Result<[G; OUT_62], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -9074,17 +9467,17 @@ fn aiur_fn_60(
     let __v_48: G = __loaded[46];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_60] = [__v_1];
-        record.function_queries[60].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_62] = [__v_1];
+        record.function_queries[62].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_60] = { let __args: [G; IN_60] = [__v_48, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[60].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_62] = { let __args: [G; IN_62] = [__v_48, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[62].get_mut(&__args[..]) { 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_49: G = __r_arr[0];
-        let __r_arr: [G; OUT_59] = { let __args: [G; IN_59] = [__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_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_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[59].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_61] = { let __args: [G; IN_61] = [__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_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_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[61].get_mut(&__args[..]) { 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_50: G = __r_arr[0];
-        let __ret: [G; OUT_60] = [__v_50];
-        record.function_queries[60].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_62] = [__v_50];
+        record.function_queries[62].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -9094,15 +9487,15 @@ fn aiur_fn_60(
   })
 }
 
-const INPUT_SIZE_61: usize = 46;
-const IN_61: usize = 46;
-const OUT_61: usize = 1;
-fn aiur_fn_61(
-  inp: [G; IN_61],
+const INPUT_SIZE_63: usize = 46;
+const IN_63: usize = 46;
+const OUT_63: usize = 1;
+fn aiur_fn_63(
+  inp: [G; IN_63],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_61], ExecError> {
+) -> 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];
@@ -9152,59 +9545,59 @@ fn aiur_fn_61(
     let __v_45: G = inp[45];
     match __v_0.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__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_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[48].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__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_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[50].get_mut(&__args[..]) { 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_46: G = __r_arr[0];
-        let __ret: [G; OUT_61] = [__v_46];
-        record.function_queries[61].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_63] = [__v_46];
+        record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_51] = { let __args: [G; IN_51] = [__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_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]; let __cu = unconstrained; if let Some(result) = record.function_queries[51].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_53] = { let __args: [G; IN_53] = [__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_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]; let __cu = unconstrained; if let Some(result) = record.function_queries[53].get_mut(&__args[..]) { 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_46: G = __r_arr[0];
-        let __ret: [G; OUT_61] = [__v_46];
-        record.function_queries[61].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_63] = [__v_46];
+        record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_52] = { let __args: [G; IN_52] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[52].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_54] = { let __args: [G; IN_54] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[54].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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_46: G = __r_arr[0];
-        let __ret: [G; OUT_61] = [__v_46];
-        record.function_queries[61].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_63] = [__v_46];
+        record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_53] = { let __args: [G; IN_53] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[53].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[55].get_mut(&__args[..]) { 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_46: G = __r_arr[0];
-        let __ret: [G; OUT_61] = [__v_46];
-        record.function_queries[61].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_63] = [__v_46];
+        record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       4u64 => {
-        let __r_arr: [G; OUT_58] = { let __args: [G; IN_58] = [__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_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[58].get_mut(&__args[..]) { 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_60] = { let __args: [G; IN_60] = [__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_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[60].get_mut(&__args[..]) { 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_46: G = __r_arr[0];
-        let __ret: [G; OUT_61] = [__v_46];
-        record.function_queries[61].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_63] = [__v_46];
+        record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       5u64 => {
-        let __r_arr: [G; OUT_57] = { let __args: [G; IN_57] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[57].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_57] = unsafe { *(result.output.as_ptr() as *const [G; OUT_57]) }; __ret } else { aiur_fn_57(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_59] = { let __args: [G; IN_59] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[59].get_mut(&__args[..]) { 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_46: G = __r_arr[0];
-        let __ret: [G; OUT_61] = [__v_46];
-        record.function_queries[61].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_63] = [__v_46];
+        record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       6u64 => {
-        let __r_arr: [G; OUT_57] = { let __args: [G; IN_57] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[57].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_57] = unsafe { *(result.output.as_ptr() as *const [G; OUT_57]) }; __ret } else { aiur_fn_57(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_59] = { let __args: [G; IN_59] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[59].get_mut(&__args[..]) { 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_46: G = __r_arr[0];
-        let __ret: [G; OUT_61] = [__v_46];
-        record.function_queries[61].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_63] = [__v_46];
+        record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       7u64 => {
-        let __r_arr: [G; OUT_57] = { let __args: [G; IN_57] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[57].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_57] = unsafe { *(result.output.as_ptr() as *const [G; OUT_57]) }; __ret } else { aiur_fn_57(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_59] = { let __args: [G; IN_59] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[59].get_mut(&__args[..]) { 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_46: G = __r_arr[0];
-        let __ret: [G; OUT_61] = [__v_46];
-        record.function_queries[61].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_63] = [__v_46];
+        record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -9214,19 +9607,19 @@ fn aiur_fn_61(
   })
 }
 
-const INPUT_SIZE_62: usize = 2;
-const IN_62: usize = 2;
-const OUT_62: usize = 1;
-fn aiur_fn_62(
-  inp: [G; IN_62],
+const INPUT_SIZE_64: usize = 2;
+const IN_64: usize = 2;
+const OUT_64: usize = 1;
+fn aiur_fn_64(
+  inp: [G; IN_64],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_62], ExecError> {
+) -> 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];
-    let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[772].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_772] = unsafe { *(result.output.as_ptr() as *const [G; OUT_772]) }; __ret } else { aiur_fn_772(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_707] = { let __args: [G; IN_707] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[707].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_707] = unsafe { *(result.output.as_ptr() as *const [G; OUT_707]) }; __ret } else { aiur_fn_707(__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];
@@ -9235,29 +9628,29 @@ fn aiur_fn_62(
     let __v_7: G = __r_arr[5];
     let __v_8: G = __r_arr[6];
     let __v_9: G = __r_arr[7];
-    let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[44].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[46].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { 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_11: G = __r_arr[0];
-    let __ret: [G; OUT_62] = [__v_11];
-    record.function_queries[62].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_64] = [__v_11];
+    record.function_queries[64].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_63: usize = 2;
-const IN_63: usize = 2;
-const OUT_63: usize = 1;
-fn aiur_fn_63(
-  inp: [G; IN_63],
+const INPUT_SIZE_65: usize = 2;
+const IN_65: usize = 2;
+const OUT_65: usize = 1;
+fn aiur_fn_65(
+  inp: [G; IN_65],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_63], ExecError> {
+) -> Result<[G; OUT_65], 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_772] = { let __args: [G; IN_772] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[772].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_772] = unsafe { *(result.output.as_ptr() as *const [G; OUT_772]) }; __ret } else { aiur_fn_772(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_707] = { let __args: [G; IN_707] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[707].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_707] = unsafe { *(result.output.as_ptr() as *const [G; OUT_707]) }; __ret } else { aiur_fn_707(__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];
@@ -9266,29 +9659,29 @@ fn aiur_fn_63(
     let __v_7: G = __r_arr[5];
     let __v_8: G = __r_arr[6];
     let __v_9: G = __r_arr[7];
-    let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[46].get_mut(&__args[..]) { 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_48] = { let __args: [G; IN_48] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[48].get_mut(&__args[..]) { 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_10: G = __r_arr[0];
-    let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { 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_11: G = __r_arr[0];
-    let __ret: [G; OUT_63] = [__v_11];
-    record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_65] = [__v_11];
+    record.function_queries[65].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 = 1;
-fn aiur_fn_64(
-  inp: [G; IN_64],
+const INPUT_SIZE_66: usize = 2;
+const IN_66: usize = 2;
+const OUT_66: usize = 1;
+fn aiur_fn_66(
+  inp: [G; IN_66],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_64], ExecError> {
+) -> 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];
-    let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[772].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_772] = unsafe { *(result.output.as_ptr() as *const [G; OUT_772]) }; __ret } else { aiur_fn_772(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_707] = { let __args: [G; IN_707] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[707].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_707] = unsafe { *(result.output.as_ptr() as *const [G; OUT_707]) }; __ret } else { aiur_fn_707(__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];
@@ -9297,25 +9690,25 @@ fn aiur_fn_64(
     let __v_7: G = __r_arr[5];
     let __v_8: G = __r_arr[6];
     let __v_9: G = __r_arr[7];
-    let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[45].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[47].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_47] = unsafe { *(result.output.as_ptr() as *const [G; OUT_47]) }; __ret } else { aiur_fn_47(__args, record, io_buffer, __cu)? } };
     let __v_10: G = __r_arr[0];
-    let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { 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_11: G = __r_arr[0];
-    let __ret: [G; OUT_64] = [__v_11];
-    record.function_queries[64].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_66] = [__v_11];
+    record.function_queries[66].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_65: usize = 49;
-const IN_65: usize = 49;
-const OUT_65: usize = 1;
-fn aiur_fn_65(
-  inp: [G; IN_65],
+const INPUT_SIZE_67: usize = 49;
+const IN_67: usize = 49;
+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_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];
@@ -9368,15 +9761,15 @@ fn aiur_fn_65(
     let __v_48: G = inp[48];
     match __v_0.as_canonical_u64() {
       _ => {
-        let __r_arr: [G; OUT_64] = { let __args: [G; IN_64] = [__v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[64].get_mut(&__args[..]) { 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_66] = { let __args: [G; IN_66] = [__v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[66].get_mut(&__args[..]) { 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_49: G = __r_arr[0];
-        let __r_arr: [G; OUT_63] = { let __args: [G; IN_63] = [__v_46, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[63].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_46, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[65].get_mut(&__args[..]) { 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_50: G = __r_arr[0];
-        let __r_arr: [G; OUT_62] = { let __args: [G; IN_62] = [__v_45, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[62].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_64] = { let __args: [G; IN_64] = [__v_45, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[64].get_mut(&__args[..]) { 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];
         match __v_0.as_canonical_u64() {
           8u64 => {
-            let __r_arr: [G; OUT_784] = { let __args: [G; IN_784] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[784].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_784] = unsafe { *(result.output.as_ptr() as *const [G; OUT_784]) }; __ret } else { aiur_fn_784(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__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];
@@ -9386,12 +9779,12 @@ fn aiur_fn_65(
             let __v_58: G = __r_arr[6];
             let __v_59: G = __r_arr[7];
             let __v_60: G = G::from_u64(12);
-            let __r_arr: [G; OUT_60] = { let __args: [G; IN_60] = [__v_1, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[60].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_62] = { let __args: [G; IN_62] = [__v_1, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[62].get_mut(&__args[..]) { 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_61: G = __r_arr[0];
-            let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_60, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { 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_33] = { let __args: [G; IN_33] = [__v_60, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { 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_62: G = __r_arr[0];
-            let __ret: [G; OUT_65] = [__v_62];
-            record.function_queries[65].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_67] = [__v_62];
+            record.function_queries[67].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
@@ -9404,12 +9797,12 @@ fn aiur_fn_65(
             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 __r_arr: [G; OUT_61] = { let __args: [G; IN_61] = [__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_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_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[61].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_63] = { let __args: [G; IN_63] = [__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_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_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[63].get_mut(&__args[..]) { 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_61: G = __r_arr[0];
-            let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { 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_33] = { let __args: [G; IN_33] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { 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_62: G = __r_arr[0];
-            let __ret: [G; OUT_65] = [__v_62];
-            record.function_queries[65].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_67] = [__v_62];
+            record.function_queries[67].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
@@ -9422,12 +9815,12 @@ fn aiur_fn_65(
             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 __r_arr: [G; OUT_61] = { let __args: [G; IN_61] = [__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_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_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[61].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_63] = { let __args: [G; IN_63] = [__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_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_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[63].get_mut(&__args[..]) { 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_61: G = __r_arr[0];
-            let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { 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_33] = { let __args: [G; IN_33] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { 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_62: G = __r_arr[0];
-            let __ret: [G; OUT_65] = [__v_62];
-            record.function_queries[65].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_67] = [__v_62];
+            record.function_queries[67].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           2u64 => {
@@ -9440,12 +9833,12 @@ fn aiur_fn_65(
             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 __r_arr: [G; OUT_61] = { let __args: [G; IN_61] = [__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_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_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[61].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_63] = { let __args: [G; IN_63] = [__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_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_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[63].get_mut(&__args[..]) { 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_61: G = __r_arr[0];
-            let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { 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_33] = { let __args: [G; IN_33] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { 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_62: G = __r_arr[0];
-            let __ret: [G; OUT_65] = [__v_62];
-            record.function_queries[65].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_67] = [__v_62];
+            record.function_queries[67].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           3u64 => {
@@ -9458,12 +9851,12 @@ fn aiur_fn_65(
             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 __r_arr: [G; OUT_61] = { let __args: [G; IN_61] = [__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_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_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[61].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_63] = { let __args: [G; IN_63] = [__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_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_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[63].get_mut(&__args[..]) { 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_61: G = __r_arr[0];
-            let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { 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_33] = { let __args: [G; IN_33] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { 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_62: G = __r_arr[0];
-            let __ret: [G; OUT_65] = [__v_62];
-            record.function_queries[65].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_67] = [__v_62];
+            record.function_queries[67].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           4u64 => {
@@ -9476,12 +9869,12 @@ fn aiur_fn_65(
             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 __r_arr: [G; OUT_61] = { let __args: [G; IN_61] = [__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_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_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[61].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_63] = { let __args: [G; IN_63] = [__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_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_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[63].get_mut(&__args[..]) { 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_61: G = __r_arr[0];
-            let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { 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_33] = { let __args: [G; IN_33] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { 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_62: G = __r_arr[0];
-            let __ret: [G; OUT_65] = [__v_62];
-            record.function_queries[65].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_67] = [__v_62];
+            record.function_queries[67].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           5u64 => {
@@ -9494,12 +9887,12 @@ fn aiur_fn_65(
             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 __r_arr: [G; OUT_61] = { let __args: [G; IN_61] = [__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_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_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[61].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_63] = { let __args: [G; IN_63] = [__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_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_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[63].get_mut(&__args[..]) { 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_61: G = __r_arr[0];
-            let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { 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_33] = { let __args: [G; IN_33] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { 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_62: G = __r_arr[0];
-            let __ret: [G; OUT_65] = [__v_62];
-            record.function_queries[65].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_67] = [__v_62];
+            record.function_queries[67].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           6u64 => {
@@ -9512,12 +9905,12 @@ fn aiur_fn_65(
             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 __r_arr: [G; OUT_61] = { let __args: [G; IN_61] = [__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_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_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[61].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_63] = { let __args: [G; IN_63] = [__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_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_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[63].get_mut(&__args[..]) { 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_61: G = __r_arr[0];
-            let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { 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_33] = { let __args: [G; IN_33] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { 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_62: G = __r_arr[0];
-            let __ret: [G; OUT_65] = [__v_62];
-            record.function_queries[65].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_67] = [__v_62];
+            record.function_queries[67].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           7u64 => {
@@ -9530,12 +9923,12 @@ fn aiur_fn_65(
             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 __r_arr: [G; OUT_61] = { let __args: [G; IN_61] = [__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_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_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[61].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_63] = { let __args: [G; IN_63] = [__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_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_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[63].get_mut(&__args[..]) { 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_61: G = __r_arr[0];
-            let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { 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_33] = { let __args: [G; IN_33] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { 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_62: G = __r_arr[0];
-            let __ret: [G; OUT_65] = [__v_62];
-            record.function_queries[65].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_67] = [__v_62];
+            record.function_queries[67].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -9547,15 +9940,15 @@ fn aiur_fn_65(
   })
 }
 
-const INPUT_SIZE_66: usize = 1;
-const IN_66: usize = 1;
-const OUT_66: usize = 2;
-fn aiur_fn_66(
-  inp: [G; IN_66],
+const INPUT_SIZE_68: usize = 1;
+const IN_68: usize = 1;
+const OUT_68: usize = 2;
+fn aiur_fn_68(
+  inp: [G; IN_68],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_66], ExecError> {
+) -> Result<[G; OUT_68], 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 };
@@ -9564,8 +9957,8 @@ fn aiur_fn_66(
     let __v_3: G = __loaded[2];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_66] = [__v_2, __v_3];
-        record.function_queries[66].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_68] = [__v_2, __v_3];
+        record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
@@ -9573,8 +9966,8 @@ fn aiur_fn_66(
         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_66] = [__v_4, __v_7];
-        record.function_queries[66].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_68] = [__v_4, __v_7];
+        record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -9584,15 +9977,15 @@ fn aiur_fn_66(
   })
 }
 
-const INPUT_SIZE_67: usize = 2;
-const IN_67: usize = 2;
-const OUT_67: usize = 9;
-fn aiur_fn_67(
-  inp: [G; IN_67],
+const INPUT_SIZE_69: usize = 2;
+const IN_69: usize = 2;
+const OUT_69: usize = 9;
+fn aiur_fn_69(
+  inp: [G; IN_69],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_67], ExecError> {
+) -> 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];
@@ -9606,8 +9999,8 @@ fn aiur_fn_67(
         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 __ret: [G; OUT_67] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_0];
-        record.function_queries[67].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_69] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_0];
+        record.function_queries[69].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -9619,7 +10012,7 @@ fn aiur_fn_67(
           0u64 => {
             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 !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 __r_arr: [G; OUT_69] = { let __args: [G; IN_69] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[69].get_mut(&__args[..]) { 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_7: G = __r_arr[0];
             let __v_8: G = __r_arr[1];
             let __v_9: G = __r_arr[2];
@@ -9629,8 +10022,8 @@ fn aiur_fn_67(
             let __v_13: G = __r_arr[6];
             let __v_14: G = __r_arr[7];
             let __v_15: G = __r_arr[8];
-            let __ret: [G; OUT_67] = [__v_3, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_15];
-            record.function_queries[67].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_69] = [__v_3, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_15];
+            record.function_queries[69].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -9642,15 +10035,15 @@ fn aiur_fn_67(
   })
 }
 
-const INPUT_SIZE_68: usize = 1;
-const IN_68: usize = 1;
-const OUT_68: usize = 9;
-fn aiur_fn_68(
-  inp: [G; IN_68],
+const INPUT_SIZE_70: usize = 1;
+const IN_70: usize = 1;
+const OUT_70: usize = 9;
+fn aiur_fn_70(
+  inp: [G; IN_70],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_68], ExecError> {
+) -> Result<[G; OUT_70], 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 };
@@ -9695,25 +10088,31 @@ fn aiur_fn_68(
             let __v_34: G = G::from_u64(0);
             let __v_35: G = G::from_u64(0);
             let __v_36: G = G::from_u64(0);
-            let __ret: [G; OUT_68] = [__v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_3];
-            record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_70] = [__v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_3];
+            record.function_queries[70].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_30: G = G::from_u64(1);
             let __v_31: G = (__v_29 + __v_30);
-            let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_3, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[67].get_mut(&__args[..]) { 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_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 __ret: [G; OUT_68] = [__v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40];
-            record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __v_32: G = G::from_u64(9);
+            let __v_33: G = if unconstrained { Bytes2::less_than(&__v_31, &__v_32) } else { bytes2_less_than_value(__v_31, __v_32, record) };
+            let __v_34: G = G::from_u64(1);
+            if (__v_33 != __v_34) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_33.as_canonical_u64(), rhs: __v_34.as_canonical_u64(), msg: Some("tag0: payload width exceeds 8 bytes".to_string()) });
+            }
+            let __r_arr: [G; OUT_69] = { let __args: [G; IN_69] = [__v_3, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[69].get_mut(&__args[..]) { 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_35: G = __r_arr[0];
+            let __v_36: G = __r_arr[1];
+            let __v_37: G = __r_arr[2];
+            let __v_38: G = __r_arr[3];
+            let __v_39: G = __r_arr[4];
+            let __v_40: G = __r_arr[5];
+            let __v_41: G = __r_arr[6];
+            let __v_42: G = __r_arr[7];
+            let __v_43: G = __r_arr[8];
+            let __ret: [G; OUT_70] = [__v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43];
+            record.function_queries[70].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -9725,15 +10124,15 @@ fn aiur_fn_68(
   })
 }
 
-const INPUT_SIZE_69: usize = 1;
-const IN_69: usize = 1;
-const OUT_69: usize = 10;
-fn aiur_fn_69(
-  inp: [G; IN_69],
+const INPUT_SIZE_71: usize = 1;
+const IN_71: usize = 1;
+const OUT_71: usize = 10;
+fn aiur_fn_71(
+  inp: [G; IN_71],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_69], ExecError> {
+) -> Result<[G; OUT_71], 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 };
@@ -9775,14 +10174,14 @@ fn aiur_fn_69(
             let __v_31: G = G::from_u64(0);
             let __v_32: G = G::from_u64(0);
             let __v_33: G = G::from_u64(0);
-            let __ret: [G; OUT_69] = [__v_14, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_3];
-            record.function_queries[69].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_71] = [__v_14, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_3];
+            record.function_queries[71].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_27: G = G::from_u64(1);
             let __v_28: G = (__v_26 + __v_27);
-            let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_3, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[67].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_69] = { let __args: [G; IN_69] = [__v_3, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[69].get_mut(&__args[..]) { 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_29: G = __r_arr[0];
             let __v_30: G = __r_arr[1];
             let __v_31: G = __r_arr[2];
@@ -9792,8 +10191,14 @@ fn aiur_fn_69(
             let __v_35: G = __r_arr[6];
             let __v_36: G = __r_arr[7];
             let __v_37: G = __r_arr[8];
-            let __ret: [G; OUT_69] = [__v_14, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37];
-            record.function_queries[69].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __v_38: G = G::from_u64(9);
+            let __v_39: G = if unconstrained { Bytes2::less_than(&__v_28, &__v_38) } else { bytes2_less_than_value(__v_28, __v_38, record) };
+            let __v_40: G = G::from_u64(1);
+            if (__v_39 != __v_40) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_39.as_canonical_u64(), rhs: __v_40.as_canonical_u64(), msg: Some("tag2: payload width exceeds 8 bytes".to_string()) });
+            }
+            let __ret: [G; OUT_71] = [__v_14, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37];
+            record.function_queries[71].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -9805,15 +10210,15 @@ fn aiur_fn_69(
   })
 }
 
-const INPUT_SIZE_70: usize = 1;
-const IN_70: usize = 1;
-const OUT_70: usize = 10;
-fn aiur_fn_70(
-  inp: [G; IN_70],
+const INPUT_SIZE_72: usize = 1;
+const IN_72: usize = 1;
+const OUT_72: usize = 10;
+fn aiur_fn_72(
+  inp: [G; IN_72],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_70], ExecError> {
+) -> Result<[G; OUT_72], 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 };
@@ -9855,14 +10260,14 @@ fn aiur_fn_70(
             let __v_31: G = G::from_u64(0);
             let __v_32: G = G::from_u64(0);
             let __v_33: G = G::from_u64(0);
-            let __ret: [G; OUT_70] = [__v_20, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_3];
-            record.function_queries[70].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_72] = [__v_20, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_3];
+            record.function_queries[72].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_27: G = G::from_u64(1);
             let __v_28: G = (__v_26 + __v_27);
-            let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_3, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[67].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_69] = { let __args: [G; IN_69] = [__v_3, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[69].get_mut(&__args[..]) { 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_29: G = __r_arr[0];
             let __v_30: G = __r_arr[1];
             let __v_31: G = __r_arr[2];
@@ -9872,8 +10277,8 @@ fn aiur_fn_70(
             let __v_35: G = __r_arr[6];
             let __v_36: G = __r_arr[7];
             let __v_37: G = __r_arr[8];
-            let __ret: [G; OUT_70] = [__v_20, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37];
-            record.function_queries[70].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_72] = [__v_20, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37];
+            record.function_queries[72].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -9885,15 +10290,15 @@ fn aiur_fn_70(
   })
 }
 
-const INPUT_SIZE_71: usize = 9;
-const IN_71: usize = 9;
-const OUT_71: usize = 2;
-fn aiur_fn_71(
-  inp: [G; IN_71],
+const INPUT_SIZE_73: usize = 9;
+const IN_73: usize = 9;
+const OUT_73: usize = 2;
+fn aiur_fn_73(
+  inp: [G; IN_73],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_71], ExecError> {
+) -> 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];
@@ -9904,19 +10309,19 @@ fn aiur_fn_71(
     let __v_6: G = inp[6];
     let __v_7: G = inp[7];
     let __v_8: G = inp[8];
-    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__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[2].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__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[4].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } else { aiur_fn_4(__args, record, io_buffer, __cu)? } };
     let __v_9: G = __r_arr[0];
     match __v_9.as_canonical_u64() {
       1u64 => {
         let __v_10: G = G::from_u64(1);
         let __v_11: G = G::from_u64(1);
         let __v_12: G = { let __values: [G; 10] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; 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_71] = [__v_12, __v_0];
-        record.function_queries[71].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_73] = [__v_12, __v_0];
+        record.function_queries[73].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[70].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_70] = unsafe { *(result.output.as_ptr() as *const [G; OUT_70]) }; __ret } else { aiur_fn_70(__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];
@@ -9926,7 +10331,7 @@ fn aiur_fn_71(
         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_12] = { let __args: [G; IN_12] = [__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[12].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_12] = unsafe { *(result.output.as_ptr() as *const [G; OUT_12]) }; __ret } else { aiur_fn_12(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__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[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__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];
@@ -9935,13 +10340,13 @@ fn aiur_fn_71(
         let __v_24: G = __r_arr[5];
         let __v_25: G = __r_arr[6];
         let __v_26: G = __r_arr[7];
-        let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = unsafe { *(result.output.as_ptr() as *const [G; OUT_71]) }; __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { 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_27: G = __r_arr[0];
         let __v_28: G = __r_arr[1];
         let __v_29: G = G::from_u64(0);
         let __v_30: G = { let __values: [G; 10] = [__v_29, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_27]; 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_71] = [__v_30, __v_28];
-        record.function_queries[71].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_73] = [__v_30, __v_28];
+        record.function_queries[73].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -9951,15 +10356,15 @@ fn aiur_fn_71(
   })
 }
 
-const INPUT_SIZE_72: usize = 10;
-const IN_72: usize = 10;
-const OUT_72: usize = 2;
-fn aiur_fn_72(
-  inp: [G; IN_72],
+const INPUT_SIZE_74: usize = 10;
+const IN_74: usize = 10;
+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_72], ExecError> {
+) -> Result<[G; OUT_74], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -9971,22 +10376,22 @@ fn aiur_fn_72(
     let __v_7: G = inp[7];
     let __v_8: G = inp[8];
     let __v_9: G = inp[9];
-    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } else { aiur_fn_4(__args, record, io_buffer, __cu)? } };
     let __v_10: G = __r_arr[0];
     match __v_10.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_72] = [__v_0, __v_1];
-        record.function_queries[72].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_74] = [__v_0, __v_1];
+        record.function_queries[74].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { 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 = G::from_u64(7);
         let __v_14: G = G::from_u64(0);
         let __v_15: G = { let __values: [G; 18] = [__v_13, __v_0, __v_11, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_12] = { let __args: [G; IN_12] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[12].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_12] = unsafe { *(result.output.as_ptr() as *const [G; OUT_12]) }; __ret } else { aiur_fn_12(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } };
         let __v_16: G = __r_arr[0];
         let __v_17: G = __r_arr[1];
         let __v_18: G = __r_arr[2];
@@ -9995,11 +10400,11 @@ fn aiur_fn_72(
         let __v_21: G = __r_arr[5];
         let __v_22: G = __r_arr[6];
         let __v_23: G = __r_arr[7];
-        let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_15, __v_12, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } else { aiur_fn_72(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_15, __v_12, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { 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_24: G = __r_arr[0];
         let __v_25: G = __r_arr[1];
-        let __ret: [G; OUT_72] = [__v_24, __v_25];
-        record.function_queries[72].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_74] = [__v_24, __v_25];
+        record.function_queries[74].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -10009,15 +10414,15 @@ fn aiur_fn_72(
   })
 }
 
-const INPUT_SIZE_73: usize = 9;
-const IN_73: usize = 9;
-const OUT_73: usize = 2;
-fn aiur_fn_73(
-  inp: [G; IN_73],
+const INPUT_SIZE_75: usize = 9;
+const IN_75: usize = 9;
+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_73], ExecError> {
+) -> 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];
@@ -10028,22 +10433,22 @@ fn aiur_fn_73(
     let __v_6: G = inp[6];
     let __v_7: G = inp[7];
     let __v_8: G = inp[8];
-    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__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[2].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__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[4].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } else { aiur_fn_4(__args, record, io_buffer, __cu)? } };
     let __v_9: G = __r_arr[0];
     match __v_9.as_canonical_u64() {
       1u64 => {
-        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 !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 __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 !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_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
-        let __ret: [G; OUT_73] = [__v_10, __v_11];
-        record.function_queries[73].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_75] = [__v_10, __v_11];
+        record.function_queries[75].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        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 !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 __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 !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_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
-        let __r_arr: [G; OUT_12] = { let __args: [G; IN_12] = [__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[12].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_12] = unsafe { *(result.output.as_ptr() as *const [G; OUT_12]) }; __ret } else { aiur_fn_12(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__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[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__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];
@@ -10052,14 +10457,14 @@ fn aiur_fn_73(
         let __v_17: G = __r_arr[5];
         let __v_18: G = __r_arr[6];
         let __v_19: G = __r_arr[7];
-        let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_11, __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[73].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_11, __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[75].get_mut(&__args[..]) { 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_20: G = __r_arr[0];
         let __v_21: G = __r_arr[1];
         let __v_22: G = G::from_u64(8);
         let __v_23: G = G::from_u64(0);
         let __v_24: G = { let __values: [G; 18] = [__v_22, __v_10, __v_20, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_24, __v_21];
-        record.function_queries[73].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_75] = [__v_24, __v_21];
+        record.function_queries[75].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -10069,15 +10474,15 @@ fn aiur_fn_73(
   })
 }
 
-const INPUT_SIZE_74: usize = 9;
-const IN_74: usize = 9;
-const OUT_74: usize = 2;
-fn aiur_fn_74(
-  inp: [G; IN_74],
+const INPUT_SIZE_76: usize = 9;
+const IN_76: usize = 9;
+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_74], ExecError> {
+) -> Result<[G; OUT_76], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -10088,22 +10493,22 @@ fn aiur_fn_74(
     let __v_6: G = inp[6];
     let __v_7: G = inp[7];
     let __v_8: G = inp[8];
-    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__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[2].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__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[4].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } else { aiur_fn_4(__args, record, io_buffer, __cu)? } };
     let __v_9: G = __r_arr[0];
     match __v_9.as_canonical_u64() {
       1u64 => {
-        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 !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 __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 !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_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
-        let __ret: [G; OUT_74] = [__v_10, __v_11];
-        record.function_queries[74].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_76] = [__v_10, __v_11];
+        record.function_queries[76].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        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 !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 __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 !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_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
-        let __r_arr: [G; OUT_12] = { let __args: [G; IN_12] = [__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[12].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_12] = unsafe { *(result.output.as_ptr() as *const [G; OUT_12]) }; __ret } else { aiur_fn_12(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__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[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__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];
@@ -10112,14 +10517,14 @@ fn aiur_fn_74(
         let __v_17: G = __r_arr[5];
         let __v_18: G = __r_arr[6];
         let __v_19: G = __r_arr[7];
-        let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_11, __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[74].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_11, __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[76].get_mut(&__args[..]) { 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_20: G = __r_arr[0];
         let __v_21: G = __r_arr[1];
         let __v_22: G = G::from_u64(9);
         let __v_23: G = G::from_u64(0);
         let __v_24: G = { let __values: [G; 18] = [__v_22, __v_10, __v_20, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_74] = [__v_24, __v_21];
-        record.function_queries[74].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_76] = [__v_24, __v_21];
+        record.function_queries[76].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -10129,18 +10534,18 @@ fn aiur_fn_74(
   })
 }
 
-const INPUT_SIZE_75: usize = 1;
-const IN_75: usize = 1;
-const OUT_75: usize = 2;
-fn aiur_fn_75(
-  inp: [G; IN_75],
+const INPUT_SIZE_77: usize = 1;
+const IN_77: usize = 1;
+const OUT_77: usize = 2;
+fn aiur_fn_77(
+  inp: [G; IN_77],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_75], ExecError> {
+) -> Result<[G; OUT_77], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[70].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_70] = unsafe { *(result.output.as_ptr() as *const [G; OUT_70]) }; __ret } else { aiur_fn_70(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } else { aiur_fn_72(__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];
@@ -10156,20 +10561,20 @@ fn aiur_fn_75(
         let __v_11: G = G::from_u64(0);
         let __v_12: G = G::from_u64(0);
         let __v_13: G = { let __values: [G; 18] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_75] = [__v_13, __v_10];
-        record.function_queries[75].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_77] = [__v_13, __v_10];
+        record.function_queries[77].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
         let __v_11: G = G::from_u64(1);
         let __v_12: G = G::from_u64(0);
         let __v_13: G = { let __values: [G; 18] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_75] = [__v_13, __v_10];
-        record.function_queries[75].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_77] = [__v_13, __v_10];
+        record.function_queries[77].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[70].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_70] = unsafe { *(result.output.as_ptr() as *const [G; OUT_70]) }; __ret } else { aiur_fn_70(__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];
@@ -10179,18 +10584,18 @@ fn aiur_fn_75(
         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_71] = { let __args: [G; IN_71] = [__v_19, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = unsafe { *(result.output.as_ptr() as *const [G; OUT_71]) }; __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_19, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { 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_20: G = __r_arr[0];
         let __v_21: G = __r_arr[1];
         let __v_22: G = G::from_u64(2);
         let __v_23: G = G::from_u64(0);
         let __v_24: G = { let __values: [G; 18] = [__v_22, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_20, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_75] = [__v_24, __v_21];
-        record.function_queries[75].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_77] = [__v_24, __v_21];
+        record.function_queries[77].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[70].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_70] = unsafe { *(result.output.as_ptr() as *const [G; OUT_70]) }; __ret } else { aiur_fn_70(__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];
@@ -10200,18 +10605,18 @@ fn aiur_fn_75(
         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_71] = { let __args: [G; IN_71] = [__v_19, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = unsafe { *(result.output.as_ptr() as *const [G; OUT_71]) }; __ret } else { aiur_fn_71(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_19, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { 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_20: G = __r_arr[0];
         let __v_21: G = __r_arr[1];
         let __v_22: G = G::from_u64(3);
         let __v_23: G = G::from_u64(0);
         let __v_24: G = { let __values: [G; 18] = [__v_22, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_20, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_75] = [__v_24, __v_21];
-        record.function_queries[75].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_77] = [__v_24, __v_21];
+        record.function_queries[77].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       4u64 => {
-        let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[70].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_70] = unsafe { *(result.output.as_ptr() as *const [G; OUT_70]) }; __ret } else { aiur_fn_70(__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];
@@ -10221,72 +10626,72 @@ fn aiur_fn_75(
         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_75] = { let __args: [G; IN_75] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { 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_20: G = __r_arr[0];
         let __v_21: G = __r_arr[1];
         let __v_22: G = G::from_u64(4);
         let __v_23: G = { let __values: [G; 18] = [__v_22, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_20]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_75] = [__v_23, __v_21];
-        record.function_queries[75].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_77] = [__v_23, __v_21];
+        record.function_queries[77].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       5u64 => {
         let __v_11: G = G::from_u64(5);
         let __v_12: G = G::from_u64(0);
         let __v_13: G = { let __values: [G; 18] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_75] = [__v_13, __v_10];
-        record.function_queries[75].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_77] = [__v_13, __v_10];
+        record.function_queries[77].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       6u64 => {
         let __v_11: G = G::from_u64(6);
         let __v_12: G = G::from_u64(0);
         let __v_13: G = { let __values: [G; 18] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_75] = [__v_13, __v_10];
-        record.function_queries[75].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_77] = [__v_13, __v_10];
+        record.function_queries[77].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       7u64 => {
-        let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { 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 __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 !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 __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_11, __v_12, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } else { aiur_fn_72(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_11, __v_12, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { 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 __ret: [G; OUT_75] = [__v_13, __v_14];
-        record.function_queries[75].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_77] = [__v_13, __v_14];
+        record.function_queries[77].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       8u64 => {
-        let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { 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_11: G = __r_arr[0];
         let __v_12: G = __r_arr[1];
-        let __ret: [G; OUT_75] = [__v_11, __v_12];
-        record.function_queries[75].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_77] = [__v_11, __v_12];
+        record.function_queries[77].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       9u64 => {
-        let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { 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_11: G = __r_arr[0];
         let __v_12: G = __r_arr[1];
-        let __ret: [G; OUT_75] = [__v_11, __v_12];
-        record.function_queries[75].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_77] = [__v_11, __v_12];
+        record.function_queries[77].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       10u64 => {
-        let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[78].get_mut(&__args[..]) { 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_11: G = __r_arr[0];
         let __v_12: G = __r_arr[1];
-        let __ret: [G; OUT_75] = [__v_11, __v_12];
-        record.function_queries[75].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_77] = [__v_11, __v_12];
+        record.function_queries[77].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       11u64 => {
         let __v_11: G = G::from_u64(11);
         let __v_12: G = G::from_u64(0);
         let __v_13: G = { let __values: [G; 18] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_75] = [__v_13, __v_10];
-        record.function_queries[75].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_77] = [__v_13, __v_10];
+        record.function_queries[77].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -10296,15 +10701,15 @@ fn aiur_fn_75(
   })
 }
 
-const INPUT_SIZE_76: usize = 9;
-const IN_76: usize = 9;
-const OUT_76: usize = 2;
-fn aiur_fn_76(
-  inp: [G; IN_76],
+const INPUT_SIZE_78: usize = 9;
+const IN_78: usize = 9;
+const OUT_78: usize = 2;
+fn aiur_fn_78(
+  inp: [G; IN_78],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_76], ExecError> {
+) -> 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];
@@ -10315,33 +10720,33 @@ fn aiur_fn_76(
     let __v_6: G = inp[6];
     let __v_7: G = inp[7];
     let __v_8: G = inp[8];
-    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 !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 __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 !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_9: G = __r_arr[0];
     let __v_10: G = __r_arr[1];
-    let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { 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 __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 !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 __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { 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_13: G = __r_arr[0];
     let __v_14: G = __r_arr[1];
     let __v_15: G = G::from_u64(10);
     let __v_16: G = G::from_u64(0);
     let __v_17: G = { let __values: [G; 18] = [__v_15, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11, __v_13, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_76] = [__v_17, __v_14];
-    record.function_queries[76].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_78] = [__v_17, __v_14];
+    record.function_queries[78].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_77: usize = 17;
-const IN_77: usize = 17;
-const OUT_77: usize = 9;
-fn aiur_fn_77(
-  inp: [G; IN_77],
+const INPUT_SIZE_79: usize = 17;
+const IN_79: usize = 17;
+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_77], ExecError> {
+) -> 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];
@@ -10360,16 +10765,16 @@ fn aiur_fn_77(
     let __v_14: G = inp[14];
     let __v_15: G = inp[15];
     let __v_16: G = inp[16];
-    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__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[2].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__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[4].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } else { aiur_fn_4(__args, record, io_buffer, __cu)? } };
     let __v_17: G = __r_arr[0];
     match __v_17.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_77] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8];
-        record.function_queries[77].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_79] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8];
+        record.function_queries[79].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_12] = { let __args: [G; IN_12] = [__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[12].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_12] = unsafe { *(result.output.as_ptr() as *const [G; OUT_12]) }; __ret } else { aiur_fn_12(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__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[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } };
         let __v_18: G = __r_arr[0];
         let __v_19: G = __r_arr[1];
         let __v_20: G = __r_arr[2];
@@ -10378,7 +10783,7 @@ fn aiur_fn_77(
         let __v_23: G = __r_arr[5];
         let __v_24: G = __r_arr[6];
         let __v_25: G = __r_arr[7];
-        let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { 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_79] = { let __args: [G; IN_79] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[79].get_mut(&__args[..]) { 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_26: G = __r_arr[0];
         let __v_27: G = __r_arr[1];
         let __v_28: G = __r_arr[2];
@@ -10391,8 +10796,8 @@ fn aiur_fn_77(
         let __v_35: G = G::from_u64(1);
         let __v_36: G = { let __values: [G; 9] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34]; let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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 = G::from_u64(0);
-        let __ret: [G; OUT_77] = [__v_35, __v_36, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37];
-        record.function_queries[77].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_79] = [__v_35, __v_36, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37];
+        record.function_queries[79].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -10402,18 +10807,18 @@ fn aiur_fn_77(
   })
 }
 
-const INPUT_SIZE_78: usize = 1;
-const IN_78: usize = 1;
-const OUT_78: usize = 10;
-fn aiur_fn_78(
-  inp: [G; IN_78],
+const INPUT_SIZE_80: usize = 1;
+const IN_80: usize = 1;
+const OUT_80: usize = 10;
+fn aiur_fn_80(
+  inp: [G; IN_80],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_78], ExecError> {
+) -> Result<[G; OUT_80], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_69] = { let __args: [G; IN_69] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[69].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = unsafe { *(result.output.as_ptr() as *const [G; OUT_71]) }; __ret } else { aiur_fn_71(__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];
@@ -10426,18 +10831,18 @@ fn aiur_fn_78(
     let __v_10: G = __r_arr[9];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } else { aiur_fn_4(__args, record, io_buffer, __cu)? } };
         let __v_11: G = __r_arr[0];
         match __v_11.as_canonical_u64() {
           1u64 => {
             let __v_12: G = G::from_u64(0);
             let __v_13: G = G::from_u64(0);
-            let __ret: [G; OUT_78] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_10];
-            record.function_queries[78].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_80] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_10];
+            record.function_queries[80].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[78].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { 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_12: G = __r_arr[0];
             let __v_13: G = __r_arr[1];
             let __v_14: G = __r_arr[2];
@@ -10448,7 +10853,7 @@ fn aiur_fn_78(
             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_77] = { let __args: [G; IN_77] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { 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_79] = { let __args: [G; IN_79] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[79].get_mut(&__args[..]) { 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_22: G = __r_arr[0];
             let __v_23: G = __r_arr[1];
             let __v_24: G = __r_arr[2];
@@ -10458,8 +10863,8 @@ fn aiur_fn_78(
             let __v_28: G = __r_arr[6];
             let __v_29: G = __r_arr[7];
             let __v_30: G = __r_arr[8];
-            let __ret: [G; OUT_78] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_21];
-            record.function_queries[78].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_80] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_21];
+            record.function_queries[80].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -10468,7 +10873,7 @@ fn aiur_fn_78(
         }
       },
       1u64 => {
-        let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[78].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { 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_11: G = __r_arr[0];
         let __v_12: G = __r_arr[1];
         let __v_13: G = __r_arr[2];
@@ -10479,7 +10884,7 @@ fn aiur_fn_78(
         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 !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 __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { 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_21: G = __r_arr[0];
         let __v_22: G = __r_arr[1];
         let __v_23: G = __r_arr[2];
@@ -10494,12 +10899,12 @@ fn aiur_fn_78(
         let __v_32: G = { let __values: [G; 9] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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; 9] = [__v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29]; let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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 = G::from_u64(0);
-        let __ret: [G; OUT_78] = [__v_31, __v_32, __v_33, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_30];
-        record.function_queries[78].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_80] = [__v_31, __v_32, __v_33, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_30];
+        record.function_queries[80].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[78].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { 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_11: G = __r_arr[0];
         let __v_12: G = __r_arr[1];
         let __v_13: G = __r_arr[2];
@@ -10510,7 +10915,7 @@ fn aiur_fn_78(
         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 !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 __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { 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_21: G = __r_arr[0];
         let __v_22: G = __r_arr[1];
         let __v_23: G = __r_arr[2];
@@ -10525,14 +10930,14 @@ fn aiur_fn_78(
         let __v_32: G = { let __values: [G; 9] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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; 9] = [__v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29]; let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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 = G::from_u64(0);
-        let __ret: [G; OUT_78] = [__v_31, __v_32, __v_33, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_30];
-        record.function_queries[78].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_80] = [__v_31, __v_32, __v_33, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_30];
+        record.function_queries[80].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
         let __v_11: G = G::from_u64(4);
-        let __ret: [G; OUT_78] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10];
-        record.function_queries[78].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_80] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10];
+        record.function_queries[80].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -10542,15 +10947,15 @@ fn aiur_fn_78(
   })
 }
 
-const INPUT_SIZE_79: usize = 1;
-const IN_79: usize = 1;
-const OUT_79: usize = 2;
-fn aiur_fn_79(
-  inp: [G; IN_79],
+const INPUT_SIZE_81: usize = 1;
+const IN_81: usize = 1;
+const OUT_81: usize = 2;
+fn aiur_fn_81(
+  inp: [G; IN_81],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_79], ExecError> {
+) -> Result<[G; OUT_81], 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 };
@@ -10746,8 +11151,8 @@ fn aiur_fn_79(
                                                                                                                                 match __v_94.as_canonical_u64() {
                                                                                                                                   0u64 => {
                                                                                                                                     let __v_97: G = { let __values: [G; 32] = [__v_2, __v_5, __v_8, __v_11, __v_14, __v_17, __v_20, __v_23, __v_26, __v_29, __v_32, __v_35, __v_38, __v_41, __v_44, __v_47, __v_50, __v_53, __v_56, __v_59, __v_62, __v_65, __v_68, __v_71, __v_74, __v_77, __v_80, __v_83, __v_86, __v_89, __v_92, __v_95]; 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_79] = [__v_97, __v_96];
-                                                                                                                                    record.function_queries[79].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                                                                                    let __ret: [G; OUT_81] = [__v_97, __v_96];
+                                                                                                                                    record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                                                                                                     return Ok(__ret);
                                                                                                                                   },
                                                                                                                                   _ => {
@@ -10912,15 +11317,15 @@ fn aiur_fn_79(
   })
 }
 
-const INPUT_SIZE_80: usize = 9;
-const IN_80: usize = 9;
-const OUT_80: usize = 2;
-fn aiur_fn_80(
-  inp: [G; IN_80],
+const INPUT_SIZE_82: usize = 9;
+const IN_82: usize = 9;
+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_80], 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];
@@ -10931,22 +11336,22 @@ fn aiur_fn_80(
     let __v_6: G = inp[6];
     let __v_7: G = inp[7];
     let __v_8: G = inp[8];
-    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__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[2].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__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[4].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } else { aiur_fn_4(__args, record, io_buffer, __cu)? } };
     let __v_9: G = __r_arr[0];
     match __v_9.as_canonical_u64() {
       1u64 => {
         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_80] = [__v_12, __v_0];
-        record.function_queries[80].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_82] = [__v_12, __v_0];
+        record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        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 !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 __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 !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_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
-        let __r_arr: [G; OUT_12] = { let __args: [G; IN_12] = [__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[12].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_12] = unsafe { *(result.output.as_ptr() as *const [G; OUT_12]) }; __ret } else { aiur_fn_12(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__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[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__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];
@@ -10955,13 +11360,13 @@ fn aiur_fn_80(
         let __v_17: G = __r_arr[5];
         let __v_18: G = __r_arr[6];
         let __v_19: G = __r_arr[7];
-        let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_11, __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[80].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_11, __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[82].get_mut(&__args[..]) { 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_20: G = __r_arr[0];
         let __v_21: G = __r_arr[1];
         let __v_22: G = G::from_u64(0);
         let __v_23: G = { let __values: [G; 3] = [__v_22, __v_10, __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 __ret: [G; OUT_80] = [__v_23, __v_21];
-        record.function_queries[80].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_82] = [__v_23, __v_21];
+        record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -10971,15 +11376,15 @@ fn aiur_fn_80(
   })
 }
 
-const INPUT_SIZE_81: usize = 9;
-const IN_81: usize = 9;
-const OUT_81: usize = 2;
-fn aiur_fn_81(
-  inp: [G; IN_81],
+const INPUT_SIZE_83: usize = 9;
+const IN_83: usize = 9;
+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_81], 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];
@@ -10990,19 +11395,19 @@ fn aiur_fn_81(
     let __v_6: G = inp[6];
     let __v_7: G = inp[7];
     let __v_8: G = inp[8];
-    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__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[2].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__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[4].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } else { aiur_fn_4(__args, record, io_buffer, __cu)? } };
     let __v_9: G = __r_arr[0];
     match __v_9.as_canonical_u64() {
       1u64 => {
         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_81] = [__v_12, __v_0];
-        record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_83] = [__v_12, __v_0];
+        record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[78].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { 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_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
         let __v_12: G = __r_arr[2];
@@ -11013,7 +11418,7 @@ fn aiur_fn_81(
         let __v_17: G = __r_arr[7];
         let __v_18: G = __r_arr[8];
         let __v_19: G = __r_arr[9];
-        let __r_arr: [G; OUT_12] = { let __args: [G; IN_12] = [__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[12].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_12] = unsafe { *(result.output.as_ptr() as *const [G; OUT_12]) }; __ret } else { aiur_fn_12(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__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[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__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];
@@ -11022,14 +11427,14 @@ fn aiur_fn_81(
         let __v_25: G = __r_arr[5];
         let __v_26: G = __r_arr[6];
         let __v_27: G = __r_arr[7];
-        let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[81].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_81] = unsafe { *(result.output.as_ptr() as *const [G; OUT_81]) }; __ret } else { aiur_fn_81(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { 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_28: G = __r_arr[0];
         let __v_29: G = __r_arr[1];
         let __v_30: G = G::from_u64(0);
         let __v_31: G = { let __values: [G; 9] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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_30, __v_31, __v_28]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_81] = [__v_32, __v_29];
-        record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_83] = [__v_32, __v_29];
+        record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -11039,15 +11444,15 @@ fn aiur_fn_81(
   })
 }
 
-const INPUT_SIZE_82: usize = 9;
-const IN_82: usize = 9;
-const OUT_82: usize = 2;
-fn aiur_fn_82(
-  inp: [G; IN_82],
+const INPUT_SIZE_84: usize = 9;
+const IN_84: usize = 9;
+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_82], 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];
@@ -11058,22 +11463,22 @@ fn aiur_fn_82(
     let __v_6: G = inp[6];
     let __v_7: G = inp[7];
     let __v_8: G = inp[8];
-    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__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[2].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__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[4].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } else { aiur_fn_4(__args, record, io_buffer, __cu)? } };
     let __v_9: G = __r_arr[0];
     match __v_9.as_canonical_u64() {
       1u64 => {
         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_82] = [__v_12, __v_0];
-        record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_84] = [__v_12, __v_0];
+        record.function_queries[84].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        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 !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 __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[81].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_81] = unsafe { *(result.output.as_ptr() as *const [G; OUT_81]) }; __ret } else { aiur_fn_81(__args, record, io_buffer, __cu)? } };
         let __v_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
-        let __r_arr: [G; OUT_12] = { let __args: [G; IN_12] = [__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[12].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_12] = unsafe { *(result.output.as_ptr() as *const [G; OUT_12]) }; __ret } else { aiur_fn_12(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__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[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__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];
@@ -11082,13 +11487,13 @@ fn aiur_fn_82(
         let __v_17: G = __r_arr[5];
         let __v_18: G = __r_arr[6];
         let __v_19: G = __r_arr[7];
-        let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_11, __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[82].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_11, __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[84].get_mut(&__args[..]) { 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_20: G = __r_arr[0];
         let __v_21: G = __r_arr[1];
         let __v_22: G = G::from_u64(0);
         let __v_23: G = { let __values: [G; 3] = [__v_22, __v_10, __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 __ret: [G; OUT_82] = [__v_23, __v_21];
-        record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_84] = [__v_23, __v_21];
+        record.function_queries[84].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -11098,18 +11503,18 @@ fn aiur_fn_82(
   })
 }
 
-const INPUT_SIZE_83: usize = 1;
-const IN_83: usize = 1;
-const OUT_83: usize = 2;
-fn aiur_fn_83(
-  inp: [G; IN_83],
+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_83], ExecError> {
+) -> Result<[G; OUT_85], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[70].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_70] = unsafe { *(result.output.as_ptr() as *const [G; OUT_70]) }; __ret } else { aiur_fn_70(__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];
@@ -11119,27 +11524,27 @@ fn aiur_fn_83(
     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_80] = { let __args: [G; IN_80] = [__v_9, __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[80].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_9, __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[82].get_mut(&__args[..]) { 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_10: G = __r_arr[0];
     let __v_11: G = __r_arr[1];
-    let __ret: [G; OUT_83] = [__v_10, __v_11];
-    record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_85] = [__v_10, __v_11];
+    record.function_queries[85].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_84: usize = 1;
-const IN_84: usize = 1;
-const OUT_84: usize = 2;
-fn aiur_fn_84(
-  inp: [G; IN_84],
+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_84], ExecError> {
+) -> Result<[G; OUT_86], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[70].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_70] = unsafe { *(result.output.as_ptr() as *const [G; OUT_70]) }; __ret } else { aiur_fn_70(__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];
@@ -11149,27 +11554,27 @@ fn aiur_fn_84(
     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_82] = { let __args: [G; IN_82] = [__v_9, __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[82].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_9, __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[84].get_mut(&__args[..]) { 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_10: G = __r_arr[0];
     let __v_11: G = __r_arr[1];
-    let __ret: [G; OUT_84] = [__v_10, __v_11];
-    record.function_queries[84].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_86] = [__v_10, __v_11];
+    record.function_queries[86].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 = 2;
-fn aiur_fn_85(
-  inp: [G; IN_85],
+const INPUT_SIZE_87: usize = 1;
+const IN_87: usize = 1;
+const OUT_87: usize = 2;
+fn aiur_fn_87(
+  inp: [G; IN_87],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_85], ExecError> {
+) -> Result<[G; OUT_87], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[70].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_70] = unsafe { *(result.output.as_ptr() as *const [G; OUT_70]) }; __ret } else { aiur_fn_70(__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];
@@ -11179,88 +11584,88 @@ fn aiur_fn_85(
     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_81] = { let __args: [G; IN_81] = [__v_9, __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[81].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_81] = unsafe { *(result.output.as_ptr() as *const [G; OUT_81]) }; __ret } else { aiur_fn_81(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_9, __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[83].get_mut(&__args[..]) { 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 __ret: [G; OUT_85] = [__v_10, __v_11];
-    record.function_queries[85].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_87] = [__v_10, __v_11];
+    record.function_queries[87].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],
+const INPUT_SIZE_88: usize = 1;
+const IN_88: usize = 1;
+const OUT_88: usize = 2;
+fn aiur_fn_88(
+  inp: [G; IN_88],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_86], ExecError> {
+) -> Result<[G; OUT_88], 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(0);
         let __v_2: G = G::from_u64(0);
-        let __ret: [G; OUT_86] = [__v_1, __v_2];
-        record.function_queries[86].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_88] = [__v_1, __v_2];
+        record.function_queries[88].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
         let __v_1: G = G::from_u64(0);
         let __v_2: G = G::from_u64(1);
-        let __ret: [G; OUT_86] = [__v_1, __v_2];
-        record.function_queries[86].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_88] = [__v_1, __v_2];
+        record.function_queries[88].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
         let __v_1: G = G::from_u64(0);
         let __v_2: G = G::from_u64(2);
-        let __ret: [G; OUT_86] = [__v_1, __v_2];
-        record.function_queries[86].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_88] = [__v_1, __v_2];
+        record.function_queries[88].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       4u64 => {
         let __v_1: G = G::from_u64(1);
         let __v_2: G = G::from_u64(0);
-        let __ret: [G; OUT_86] = [__v_1, __v_2];
-        record.function_queries[86].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_88] = [__v_1, __v_2];
+        record.function_queries[88].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       5u64 => {
         let __v_1: G = G::from_u64(1);
         let __v_2: G = G::from_u64(1);
-        let __ret: [G; OUT_86] = [__v_1, __v_2];
-        record.function_queries[86].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_88] = [__v_1, __v_2];
+        record.function_queries[88].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       6u64 => {
         let __v_1: G = G::from_u64(1);
         let __v_2: G = G::from_u64(2);
-        let __ret: [G; OUT_86] = [__v_1, __v_2];
-        record.function_queries[86].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_88] = [__v_1, __v_2];
+        record.function_queries[88].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       8u64 => {
         let __v_1: G = G::from_u64(2);
         let __v_2: G = G::from_u64(0);
-        let __ret: [G; OUT_86] = [__v_1, __v_2];
-        record.function_queries[86].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_88] = [__v_1, __v_2];
+        record.function_queries[88].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       9u64 => {
         let __v_1: G = G::from_u64(2);
         let __v_2: G = G::from_u64(1);
-        let __ret: [G; OUT_86] = [__v_1, __v_2];
-        record.function_queries[86].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_88] = [__v_1, __v_2];
+        record.function_queries[88].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       10u64 => {
         let __v_1: G = G::from_u64(2);
         let __v_2: G = G::from_u64(2);
-        let __ret: [G; OUT_86] = [__v_1, __v_2];
-        record.function_queries[86].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_88] = [__v_1, __v_2];
+        record.function_queries[88].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -11270,24 +11675,24 @@ fn aiur_fn_86(
   })
 }
 
-const INPUT_SIZE_87: usize = 1;
-const IN_87: usize = 1;
-const OUT_87: usize = 13;
-fn aiur_fn_87(
-  inp: [G; IN_87],
+const INPUT_SIZE_89: usize = 1;
+const IN_89: usize = 1;
+const OUT_89: usize = 13;
+fn aiur_fn_89(
+  inp: [G; IN_89],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_87], ExecError> {
+) -> Result<[G; OUT_89], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[66].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { 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_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
-    let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[86].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[88].get_mut(&__args[..]) { 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_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
-    let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[70].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_70] = unsafe { *(result.output.as_ptr() as *const [G; OUT_70]) }; __ret } else { aiur_fn_70(__args, record, io_buffer, __cu)? } };
     let __v_5: G = __r_arr[0];
     let __v_6: G = __r_arr[1];
     let __v_7: G = __r_arr[2];
@@ -11297,30 +11702,30 @@ fn aiur_fn_87(
     let __v_11: G = __r_arr[6];
     let __v_12: G = __r_arr[7];
     let __v_13: G = __r_arr[8];
-    let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { 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_14: G = __r_arr[0];
     let __v_15: G = __r_arr[1];
-    let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { 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_16: G = __r_arr[0];
     let __v_17: G = __r_arr[1];
-    let __ret: [G; OUT_87] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_14, __v_16, __v_17];
-    record.function_queries[87].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_89] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_14, __v_16, __v_17];
+    record.function_queries[89].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],
+const INPUT_SIZE_90: usize = 1;
+const IN_90: usize = 1;
+const OUT_90: usize = 10;
+fn aiur_fn_90(
+  inp: [G; IN_90],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_88], ExecError> {
+) -> Result<[G; OUT_90], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[70].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_70] = unsafe { *(result.output.as_ptr() as *const [G; OUT_70]) }; __ret } else { aiur_fn_70(__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];
@@ -11330,24 +11735,24 @@ fn aiur_fn_88(
     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_75] = { let __args: [G; IN_75] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { 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_10: G = __r_arr[0];
     let __v_11: G = __r_arr[1];
-    let __ret: [G; OUT_88] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11];
-    record.function_queries[88].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_90] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11];
+    record.function_queries[90].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_89: usize = 9;
-const IN_89: usize = 9;
-const OUT_89: usize = 2;
-fn aiur_fn_89(
-  inp: [G; IN_89],
+const INPUT_SIZE_91: usize = 9;
+const IN_91: usize = 9;
+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_89], 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];
@@ -11358,19 +11763,19 @@ fn aiur_fn_89(
     let __v_6: G = inp[6];
     let __v_7: G = inp[7];
     let __v_8: G = inp[8];
-    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__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[2].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__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[4].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } else { aiur_fn_4(__args, record, io_buffer, __cu)? } };
     let __v_9: G = __r_arr[0];
     match __v_9.as_canonical_u64() {
       1u64 => {
         let __v_10: G = G::from_u64(1);
         let __v_11: G = G::from_u64(1);
         let __v_12: G = { let __values: [G; 11] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_12, __v_0];
-        record.function_queries[89].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_91] = [__v_12, __v_0];
+        record.function_queries[91].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[88].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[90].get_mut(&__args[..]) { 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_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
         let __v_12: G = __r_arr[2];
@@ -11381,7 +11786,7 @@ fn aiur_fn_89(
         let __v_17: G = __r_arr[7];
         let __v_18: G = __r_arr[8];
         let __v_19: G = __r_arr[9];
-        let __r_arr: [G; OUT_12] = { let __args: [G; IN_12] = [__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[12].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_12] = unsafe { *(result.output.as_ptr() as *const [G; OUT_12]) }; __ret } else { aiur_fn_12(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__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[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__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];
@@ -11390,13 +11795,13 @@ fn aiur_fn_89(
         let __v_25: G = __r_arr[5];
         let __v_26: G = __r_arr[6];
         let __v_27: G = __r_arr[7];
-        let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[89].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_91] = { let __args: [G; IN_91] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[91].get_mut(&__args[..]) { 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_28: G = __r_arr[0];
         let __v_29: G = __r_arr[1];
         let __v_30: G = G::from_u64(0);
         let __v_31: G = { let __values: [G; 11] = [__v_30, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_28]; let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_31, __v_29];
-        record.function_queries[89].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_91] = [__v_31, __v_29];
+        record.function_queries[91].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -11406,18 +11811,18 @@ fn aiur_fn_89(
   })
 }
 
-const INPUT_SIZE_90: usize = 1;
-const IN_90: usize = 1;
-const OUT_90: usize = 45;
-fn aiur_fn_90(
-  inp: [G; IN_90],
+const INPUT_SIZE_92: usize = 1;
+const IN_92: usize = 1;
+const OUT_92: usize = 45;
+fn aiur_fn_92(
+  inp: [G; IN_92],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_90], ExecError> {
+) -> Result<[G; OUT_92], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[66].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { 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_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
     let __b1_out: [G; 8] = if unconstrained { let __v: Vec<G> = Bytes1::bit_decompose(&__v_1); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_1, record) };
@@ -11429,7 +11834,7 @@ fn aiur_fn_90(
     let __v_8: G = __b1_out[5];
     let __v_9: G = __b1_out[6];
     let __v_10: G = __b1_out[7];
-    let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[70].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_70] = unsafe { *(result.output.as_ptr() as *const [G; OUT_70]) }; __ret } else { aiur_fn_70(__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];
@@ -11439,7 +11844,7 @@ fn aiur_fn_90(
     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_68] = { let __args: [G; IN_68] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[70].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_70] = unsafe { *(result.output.as_ptr() as *const [G; OUT_70]) }; __ret } else { aiur_fn_70(__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];
@@ -11449,7 +11854,7 @@ fn aiur_fn_90(
     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_68] = { let __args: [G; IN_68] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[70].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_70] = unsafe { *(result.output.as_ptr() as *const [G; OUT_70]) }; __ret } else { aiur_fn_70(__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];
@@ -11459,7 +11864,7 @@ fn aiur_fn_90(
     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_68] = { let __args: [G; IN_68] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[70].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_70] = unsafe { *(result.output.as_ptr() as *const [G; OUT_70]) }; __ret } else { aiur_fn_70(__args, record, io_buffer, __cu)? } };
     let __v_38: G = __r_arr[0];
     let __v_39: G = __r_arr[1];
     let __v_40: G = __r_arr[2];
@@ -11469,7 +11874,7 @@ fn aiur_fn_90(
     let __v_44: G = __r_arr[6];
     let __v_45: G = __r_arr[7];
     let __v_46: G = __r_arr[8];
-    let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[70].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_70] = unsafe { *(result.output.as_ptr() as *const [G; OUT_70]) }; __ret } else { aiur_fn_70(__args, record, io_buffer, __cu)? } };
     let __v_47: G = __r_arr[0];
     let __v_48: G = __r_arr[1];
     let __v_49: G = __r_arr[2];
@@ -11479,10 +11884,10 @@ fn aiur_fn_90(
     let __v_53: G = __r_arr[6];
     let __v_54: G = __r_arr[7];
     let __v_55: G = __r_arr[8];
-    let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { 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_56: G = __r_arr[0];
     let __v_57: G = __r_arr[1];
-    let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_57]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_57]; let __cu = unconstrained; if let Some(result) = record.function_queries[70].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_70] = unsafe { *(result.output.as_ptr() as *const [G; OUT_70]) }; __ret } else { aiur_fn_70(__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];
@@ -11492,30 +11897,30 @@ fn aiur_fn_90(
     let __v_64: G = __r_arr[6];
     let __v_65: G = __r_arr[7];
     let __v_66: G = __r_arr[8];
-    let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_66, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65]; let __cu = unconstrained; if let Some(result) = record.function_queries[89].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_91] = { let __args: [G; IN_91] = [__v_66, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65]; let __cu = unconstrained; if let Some(result) = record.function_queries[91].get_mut(&__args[..]) { 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_67: G = __r_arr[0];
     let __v_68: G = __r_arr[1];
-    let __ret: [G; OUT_90] = [__v_3, __v_4, __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, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_56, __v_67, __v_68];
-    record.function_queries[90].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_92] = [__v_3, __v_4, __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, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_56, __v_67, __v_68];
+    record.function_queries[92].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 = 11;
-fn aiur_fn_91(
-  inp: [G; IN_91],
+const INPUT_SIZE_93: usize = 1;
+const IN_93: usize = 1;
+const OUT_93: usize = 11;
+fn aiur_fn_93(
+  inp: [G; IN_93],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_91], ExecError> {
+) -> Result<[G; OUT_93], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[66].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { 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_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
-    let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[70].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_70] = unsafe { *(result.output.as_ptr() as *const [G; OUT_70]) }; __ret } else { aiur_fn_70(__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];
@@ -11525,49 +11930,49 @@ fn aiur_fn_91(
     let __v_9: G = __r_arr[6];
     let __v_10: G = __r_arr[7];
     let __v_11: G = __r_arr[8];
-    let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { 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 __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 !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 __ret: [G; OUT_91] = [__v_1, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_12, __v_13];
-    record.function_queries[91].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_93] = [__v_1, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_12, __v_13];
+    record.function_queries[93].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_92: usize = 1;
-const IN_92: usize = 1;
-const OUT_92: usize = 1;
-fn aiur_fn_92(
-  inp: [G; IN_92],
+const INPUT_SIZE_94: usize = 1;
+const IN_94: usize = 1;
+const OUT_94: usize = 1;
+fn aiur_fn_94(
+  inp: [G; IN_94],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_92], ExecError> {
+) -> Result<[G; OUT_94], 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(0);
-        let __ret: [G; OUT_92] = [__v_1];
-        record.function_queries[92].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_94] = [__v_1];
+        record.function_queries[94].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
         let __v_1: G = G::from_u64(1);
-        let __ret: [G; OUT_92] = [__v_1];
-        record.function_queries[92].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_94] = [__v_1];
+        record.function_queries[94].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
         let __v_1: G = G::from_u64(2);
-        let __ret: [G; OUT_92] = [__v_1];
-        record.function_queries[92].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_94] = [__v_1];
+        record.function_queries[94].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
         let __v_1: G = G::from_u64(3);
-        let __ret: [G; OUT_92] = [__v_1];
-        record.function_queries[92].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_94] = [__v_1];
+        record.function_queries[94].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -11577,23 +11982,23 @@ fn aiur_fn_92(
   })
 }
 
-const INPUT_SIZE_93: usize = 1;
-const IN_93: usize = 1;
-const OUT_93: usize = 11;
-fn aiur_fn_93(
-  inp: [G; IN_93],
+const INPUT_SIZE_95: usize = 1;
+const IN_95: usize = 1;
+const OUT_95: usize = 11;
+fn aiur_fn_95(
+  inp: [G; IN_95],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_93], ExecError> {
+) -> Result<[G; OUT_95], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[66].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { 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_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
-    let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[92].get_mut(&__args[..]) { 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_94] = { let __args: [G; IN_94] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[94].get_mut(&__args[..]) { 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_3: G = __r_arr[0];
-    let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[70].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_70] = unsafe { *(result.output.as_ptr() as *const [G; OUT_70]) }; __ret } else { aiur_fn_70(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
     let __v_5: G = __r_arr[1];
     let __v_6: G = __r_arr[2];
@@ -11603,30 +12008,30 @@ fn aiur_fn_93(
     let __v_10: G = __r_arr[6];
     let __v_11: G = __r_arr[7];
     let __v_12: G = __r_arr[8];
-    let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { 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_13: G = __r_arr[0];
     let __v_14: G = __r_arr[1];
-    let __ret: [G; OUT_93] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_13, __v_14];
-    record.function_queries[93].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_95] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_13, __v_14];
+    record.function_queries[95].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 = 35;
-fn aiur_fn_94(
-  inp: [G; IN_94],
+const INPUT_SIZE_96: usize = 1;
+const IN_96: usize = 1;
+const OUT_96: usize = 35;
+fn aiur_fn_96(
+  inp: [G; IN_96],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_94], ExecError> {
+) -> Result<[G; OUT_96], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[66].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { 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_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
-    let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[70].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_70] = unsafe { *(result.output.as_ptr() as *const [G; OUT_70]) }; __ret } else { aiur_fn_70(__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];
@@ -11636,7 +12041,7 @@ fn aiur_fn_94(
     let __v_9: G = __r_arr[6];
     let __v_10: G = __r_arr[7];
     let __v_11: G = __r_arr[8];
-    let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[70].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_70] = unsafe { *(result.output.as_ptr() as *const [G; OUT_70]) }; __ret } else { aiur_fn_70(__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];
@@ -11646,7 +12051,7 @@ fn aiur_fn_94(
     let __v_18: G = __r_arr[6];
     let __v_19: G = __r_arr[7];
     let __v_20: G = __r_arr[8];
-    let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[70].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_70] = unsafe { *(result.output.as_ptr() as *const [G; OUT_70]) }; __ret } else { aiur_fn_70(__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];
@@ -11656,7 +12061,7 @@ fn aiur_fn_94(
     let __v_27: G = __r_arr[6];
     let __v_28: G = __r_arr[7];
     let __v_29: G = __r_arr[8];
-    let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[70].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_70] = unsafe { *(result.output.as_ptr() as *const [G; OUT_70]) }; __ret } else { aiur_fn_70(__args, record, io_buffer, __cu)? } };
     let __v_30: G = __r_arr[0];
     let __v_31: G = __r_arr[1];
     let __v_32: G = __r_arr[2];
@@ -11666,24 +12071,24 @@ fn aiur_fn_94(
     let __v_36: G = __r_arr[6];
     let __v_37: G = __r_arr[7];
     let __v_38: G = __r_arr[8];
-    let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { 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_39: G = __r_arr[0];
     let __v_40: G = __r_arr[1];
-    let __ret: [G; OUT_94] = [__v_1, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_39, __v_40];
-    record.function_queries[94].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_96] = [__v_1, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_39, __v_40];
+    record.function_queries[96].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_95: usize = 9;
-const IN_95: usize = 9;
-const OUT_95: usize = 2;
-fn aiur_fn_95(
-  inp: [G; IN_95],
+const INPUT_SIZE_97: usize = 9;
+const IN_97: usize = 9;
+const OUT_97: usize = 2;
+fn aiur_fn_97(
+  inp: [G; IN_97],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_95], ExecError> {
+) -> 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];
@@ -11694,19 +12099,19 @@ fn aiur_fn_95(
     let __v_6: G = inp[6];
     let __v_7: G = inp[7];
     let __v_8: G = inp[8];
-    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__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[2].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__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[4].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } else { aiur_fn_4(__args, record, io_buffer, __cu)? } };
     let __v_9: G = __r_arr[0];
     match __v_9.as_canonical_u64() {
       1u64 => {
         let __v_10: G = G::from_u64(1);
         let __v_11: G = G::from_u64(1);
         let __v_12: G = { let __values: [G; 36] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&36).ok_or(ExecError::InvalidMemorySize(36))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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, __v_0];
-        record.function_queries[95].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_97] = [__v_12, __v_0];
+        record.function_queries[97].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[94].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[96].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_96] = unsafe { *(result.output.as_ptr() as *const [G; OUT_96]) }; __ret } else { aiur_fn_96(__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];
@@ -11742,7 +12147,7 @@ fn aiur_fn_95(
         let __v_42: G = __r_arr[32];
         let __v_43: G = __r_arr[33];
         let __v_44: G = __r_arr[34];
-        let __r_arr: [G; OUT_12] = { let __args: [G; IN_12] = [__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[12].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_12] = unsafe { *(result.output.as_ptr() as *const [G; OUT_12]) }; __ret } else { aiur_fn_12(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__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[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } };
         let __v_45: G = __r_arr[0];
         let __v_46: G = __r_arr[1];
         let __v_47: G = __r_arr[2];
@@ -11751,13 +12156,13 @@ fn aiur_fn_95(
         let __v_50: G = __r_arr[5];
         let __v_51: G = __r_arr[6];
         let __v_52: G = __r_arr[7];
-        let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[95].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_97] = { let __args: [G; IN_97] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[97].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_97] = unsafe { *(result.output.as_ptr() as *const [G; OUT_97]) }; __ret } else { aiur_fn_97(__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 __v_56: G = { let __values: [G; 36] = [__v_55, __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_53]; let __mq = record.memory_queries.get_mut(&36).ok_or(ExecError::InvalidMemorySize(36))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_56, __v_54];
-        record.function_queries[95].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_97] = [__v_56, __v_54];
+        record.function_queries[97].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -11767,18 +12172,18 @@ fn aiur_fn_95(
   })
 }
 
-const INPUT_SIZE_96: usize = 1;
-const IN_96: usize = 1;
-const OUT_96: usize = 28;
-fn aiur_fn_96(
-  inp: [G; IN_96],
+const INPUT_SIZE_98: usize = 1;
+const IN_98: usize = 1;
+const OUT_98: usize = 28;
+fn aiur_fn_98(
+  inp: [G; IN_98],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_96], ExecError> {
+) -> Result<[G; OUT_98], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[66].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { 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_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
     let __b1_out: [G; 8] = if unconstrained { let __v: Vec<G> = Bytes1::bit_decompose(&__v_1); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_1, record) };
@@ -11790,7 +12195,7 @@ fn aiur_fn_96(
     let __v_8: G = __b1_out[5];
     let __v_9: G = __b1_out[6];
     let __v_10: G = __b1_out[7];
-    let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[70].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_70] = unsafe { *(result.output.as_ptr() as *const [G; OUT_70]) }; __ret } else { aiur_fn_70(__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];
@@ -11800,7 +12205,7 @@ fn aiur_fn_96(
     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_68] = { let __args: [G; IN_68] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[70].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_70] = unsafe { *(result.output.as_ptr() as *const [G; OUT_70]) }; __ret } else { aiur_fn_70(__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];
@@ -11810,7 +12215,7 @@ fn aiur_fn_96(
     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_68] = { let __args: [G; IN_68] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[70].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_70] = unsafe { *(result.output.as_ptr() as *const [G; OUT_70]) }; __ret } else { aiur_fn_70(__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];
@@ -11820,10 +12225,10 @@ fn aiur_fn_96(
     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_75] = { let __args: [G; IN_75] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { 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_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 !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 __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[70].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_70] = unsafe { *(result.output.as_ptr() as *const [G; OUT_70]) }; __ret } else { aiur_fn_70(__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];
@@ -11833,27 +12238,27 @@ fn aiur_fn_96(
     let __v_46: G = __r_arr[6];
     let __v_47: G = __r_arr[7];
     let __v_48: G = __r_arr[8];
-    let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_48, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[95].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_97] = { let __args: [G; IN_97] = [__v_48, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[97].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_97] = unsafe { *(result.output.as_ptr() as *const [G; OUT_97]) }; __ret } else { aiur_fn_97(__args, record, io_buffer, __cu)? } };
     let __v_49: G = __r_arr[0];
     let __v_50: G = __r_arr[1];
-    let __ret: [G; OUT_96] = [__v_3, __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, __v_38, __v_49, __v_50];
-    record.function_queries[96].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_98] = [__v_3, __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, __v_38, __v_49, __v_50];
+    record.function_queries[98].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_97: usize = 1;
-const IN_97: usize = 1;
-const OUT_97: usize = 10;
-fn aiur_fn_97(
-  inp: [G; IN_97],
+const INPUT_SIZE_99: usize = 1;
+const IN_99: usize = 1;
+const OUT_99: usize = 10;
+fn aiur_fn_99(
+  inp: [G; IN_99],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_97], ExecError> {
+) -> Result<[G; OUT_99], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[70].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_70] = unsafe { *(result.output.as_ptr() as *const [G; OUT_70]) }; __ret } else { aiur_fn_70(__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];
@@ -11863,27 +12268,27 @@ fn aiur_fn_97(
     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 !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 __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[81].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_81] = unsafe { *(result.output.as_ptr() as *const [G; OUT_81]) }; __ret } else { aiur_fn_81(__args, record, io_buffer, __cu)? } };
     let __v_10: G = __r_arr[0];
     let __v_11: G = __r_arr[1];
-    let __ret: [G; OUT_97] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11];
-    record.function_queries[97].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_99] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11];
+    record.function_queries[99].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_98: usize = 1;
-const IN_98: usize = 1;
-const OUT_98: usize = 18;
-fn aiur_fn_98(
-  inp: [G; IN_98],
+const INPUT_SIZE_100: usize = 1;
+const IN_100: usize = 1;
+const OUT_100: usize = 18;
+fn aiur_fn_100(
+  inp: [G; IN_100],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_98], ExecError> {
+) -> Result<[G; OUT_100], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[70].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_70] = unsafe { *(result.output.as_ptr() as *const [G; OUT_70]) }; __ret } else { aiur_fn_70(__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];
@@ -11893,7 +12298,7 @@ fn aiur_fn_98(
     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_68] = { let __args: [G; IN_68] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[70].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_70] = unsafe { *(result.output.as_ptr() as *const [G; OUT_70]) }; __ret } else { aiur_fn_70(__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];
@@ -11903,32 +12308,32 @@ fn aiur_fn_98(
     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 !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 __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[81].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_81] = unsafe { *(result.output.as_ptr() as *const [G; OUT_81]) }; __ret } else { aiur_fn_81(__args, record, io_buffer, __cu)? } };
     let __v_19: G = __r_arr[0];
     let __v_20: G = __r_arr[1];
-    let __ret: [G; OUT_98] = [__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];
-    record.function_queries[98].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_100] = [__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];
+    record.function_queries[100].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 = 46;
-fn aiur_fn_99(
-  inp: [G; IN_99],
+const INPUT_SIZE_101: usize = 1;
+const IN_101: usize = 1;
+const OUT_101: usize = 46;
+fn aiur_fn_101(
+  inp: [G; IN_101],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_99], ExecError> {
+) -> Result<[G; OUT_101], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[66].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { 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_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[87].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[89].get_mut(&__args[..]) { 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_3: G = __r_arr[0];
         let __v_4: G = __r_arr[1];
         let __v_5: G = __r_arr[2];
@@ -11944,12 +12349,12 @@ fn aiur_fn_99(
         let __v_15: G = __r_arr[12];
         let __v_16: G = G::from_u64(0);
         let __v_17: G = G::from_u64(0);
-        let __ret: [G; OUT_99] = [__v_16, __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_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_15];
-        record.function_queries[99].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_101] = [__v_16, __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_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_15];
+        record.function_queries[101].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[96].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_96] = unsafe { *(result.output.as_ptr() as *const [G; OUT_96]) }; __ret } else { aiur_fn_96(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[98].get_mut(&__args[..]) { 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 __v_4: G = __r_arr[1];
         let __v_5: G = __r_arr[2];
@@ -11980,12 +12385,12 @@ fn aiur_fn_99(
         let __v_30: G = __r_arr[27];
         let __v_31: G = G::from_u64(1);
         let __v_32: G = G::from_u64(0);
-        let __ret: [G; OUT_99] = [__v_31, __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_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_30];
-        record.function_queries[99].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_101] = [__v_31, __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_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_30];
+        record.function_queries[101].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[90].get_mut(&__args[..]) { 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_92] = { let __args: [G; IN_92] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[92].get_mut(&__args[..]) { 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_3: G = __r_arr[0];
         let __v_4: G = __r_arr[1];
         let __v_5: G = __r_arr[2];
@@ -12032,8 +12437,8 @@ fn aiur_fn_99(
         let __v_46: G = __r_arr[43];
         let __v_47: G = __r_arr[44];
         let __v_48: G = G::from_u64(2);
-        let __ret: [G; OUT_99] = [__v_48, __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_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];
-        record.function_queries[99].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_101] = [__v_48, __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_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];
+        record.function_queries[101].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -12043,15 +12448,15 @@ fn aiur_fn_99(
   })
 }
 
-const INPUT_SIZE_100: usize = 9;
-const IN_100: usize = 9;
-const OUT_100: usize = 2;
-fn aiur_fn_100(
-  inp: [G; IN_100],
+const INPUT_SIZE_102: usize = 9;
+const IN_102: usize = 9;
+const OUT_102: usize = 2;
+fn aiur_fn_102(
+  inp: [G; IN_102],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_100], ExecError> {
+) -> 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];
@@ -12062,19 +12467,19 @@ fn aiur_fn_100(
     let __v_6: G = inp[6];
     let __v_7: G = inp[7];
     let __v_8: G = inp[8];
-    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__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[2].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__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[4].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } else { aiur_fn_4(__args, record, io_buffer, __cu)? } };
     let __v_9: G = __r_arr[0];
     match __v_9.as_canonical_u64() {
       1u64 => {
         let __v_10: G = G::from_u64(1);
         let __v_11: G = G::from_u64(1);
         let __v_12: G = { let __values: [G; 47] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_12, __v_0];
-        record.function_queries[100].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_102] = [__v_12, __v_0];
+        record.function_queries[102].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_99] = { let __args: [G; IN_99] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[99].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_101] = { let __args: [G; IN_101] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[101].get_mut(&__args[..]) { 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_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
         let __v_12: G = __r_arr[2];
@@ -12121,7 +12526,7 @@ fn aiur_fn_100(
         let __v_53: G = __r_arr[43];
         let __v_54: G = __r_arr[44];
         let __v_55: G = __r_arr[45];
-        let __r_arr: [G; OUT_12] = { let __args: [G; IN_12] = [__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[12].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_12] = unsafe { *(result.output.as_ptr() as *const [G; OUT_12]) }; __ret } else { aiur_fn_12(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__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[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__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];
@@ -12130,13 +12535,13 @@ fn aiur_fn_100(
         let __v_61: G = __r_arr[5];
         let __v_62: G = __r_arr[6];
         let __v_63: G = __r_arr[7];
-        let __r_arr: [G; OUT_100] = { let __args: [G; IN_100] = [__v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[100].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[102].get_mut(&__args[..]) { 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_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; 47] = [__v_66, __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_64]; let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_67, __v_65];
-        record.function_queries[100].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_102] = [__v_67, __v_65];
+        record.function_queries[102].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -12146,21 +12551,21 @@ fn aiur_fn_100(
   })
 }
 
-const INPUT_SIZE_101: usize = 2;
-const IN_101: usize = 2;
-const OUT_101: usize = 46;
-fn aiur_fn_101(
-  inp: [G; IN_101],
+const INPUT_SIZE_103: usize = 2;
+const IN_103: usize = 2;
+const OUT_103: usize = 46;
+fn aiur_fn_103(
+  inp: [G; IN_103],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_101], ExecError> {
+) -> 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];
     match __v_0.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[87].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[89].get_mut(&__args[..]) { 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];
@@ -12176,12 +12581,12 @@ fn aiur_fn_101(
         let __v_14: G = __r_arr[12];
         let __v_15: G = G::from_u64(0);
         let __v_16: G = G::from_u64(0);
-        let __ret: [G; OUT_101] = [__v_15, __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_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_14];
-        record.function_queries[101].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_103] = [__v_15, __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_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_14];
+        record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[90].get_mut(&__args[..]) { 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_92] = { let __args: [G; IN_92] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[92].get_mut(&__args[..]) { 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_2: G = __r_arr[0];
         let __v_3: G = __r_arr[1];
         let __v_4: G = __r_arr[2];
@@ -12228,12 +12633,12 @@ fn aiur_fn_101(
         let __v_45: G = __r_arr[43];
         let __v_46: G = __r_arr[44];
         let __v_47: G = G::from_u64(1);
-        let __ret: [G; OUT_101] = [__v_47, __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_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46];
-        record.function_queries[101].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_103] = [__v_47, __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_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46];
+        record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_91] = { let __args: [G; IN_91] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[91].get_mut(&__args[..]) { 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_93] = { let __args: [G; IN_93] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[93].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_93] = unsafe { *(result.output.as_ptr() as *const [G; OUT_93]) }; __ret } else { aiur_fn_93(__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];
@@ -12247,12 +12652,12 @@ fn aiur_fn_101(
         let __v_12: G = __r_arr[10];
         let __v_13: G = G::from_u64(2);
         let __v_14: G = G::from_u64(0);
-        let __ret: [G; OUT_101] = [__v_13, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_12];
-        record.function_queries[101].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_103] = [__v_13, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_12];
+        record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[93].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_93] = unsafe { *(result.output.as_ptr() as *const [G; OUT_93]) }; __ret } else { aiur_fn_93(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[95].get_mut(&__args[..]) { 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_2: G = __r_arr[0];
         let __v_3: G = __r_arr[1];
         let __v_4: G = __r_arr[2];
@@ -12266,12 +12671,12 @@ fn aiur_fn_101(
         let __v_12: G = __r_arr[10];
         let __v_13: G = G::from_u64(3);
         let __v_14: G = G::from_u64(0);
-        let __ret: [G; OUT_101] = [__v_13, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_12];
-        record.function_queries[101].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_103] = [__v_13, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_12];
+        record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       4u64 => {
-        let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[98].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_100] = { let __args: [G; IN_100] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[100].get_mut(&__args[..]) { 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_2: G = __r_arr[0];
         let __v_3: G = __r_arr[1];
         let __v_4: G = __r_arr[2];
@@ -12292,12 +12697,12 @@ fn aiur_fn_101(
         let __v_19: G = __r_arr[17];
         let __v_20: G = G::from_u64(4);
         let __v_21: G = G::from_u64(0);
-        let __ret: [G; OUT_101] = [__v_20, __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_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_19];
-        record.function_queries[101].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_103] = [__v_20, __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_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_19];
+        record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       5u64 => {
-        let __r_arr: [G; OUT_97] = { let __args: [G; IN_97] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[97].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_97] = unsafe { *(result.output.as_ptr() as *const [G; OUT_97]) }; __ret } else { aiur_fn_97(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_99] = { let __args: [G; IN_99] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[99].get_mut(&__args[..]) { 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_2: G = __r_arr[0];
         let __v_3: G = __r_arr[1];
         let __v_4: G = __r_arr[2];
@@ -12310,12 +12715,12 @@ fn aiur_fn_101(
         let __v_11: G = __r_arr[9];
         let __v_12: G = G::from_u64(5);
         let __v_13: G = G::from_u64(0);
-        let __ret: [G; OUT_101] = [__v_12, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_11];
-        record.function_queries[101].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_103] = [__v_12, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_11];
+        record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       6u64 => {
-        let __r_arr: [G; OUT_97] = { let __args: [G; IN_97] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[97].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_97] = unsafe { *(result.output.as_ptr() as *const [G; OUT_97]) }; __ret } else { aiur_fn_97(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_99] = { let __args: [G; IN_99] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[99].get_mut(&__args[..]) { 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_2: G = __r_arr[0];
         let __v_3: G = __r_arr[1];
         let __v_4: G = __r_arr[2];
@@ -12328,12 +12733,12 @@ fn aiur_fn_101(
         let __v_11: G = __r_arr[9];
         let __v_12: G = G::from_u64(6);
         let __v_13: G = G::from_u64(0);
-        let __ret: [G; OUT_101] = [__v_12, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_11];
-        record.function_queries[101].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_103] = [__v_12, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_11];
+        record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       7u64 => {
-        let __r_arr: [G; OUT_97] = { let __args: [G; IN_97] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[97].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_97] = unsafe { *(result.output.as_ptr() as *const [G; OUT_97]) }; __ret } else { aiur_fn_97(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_99] = { let __args: [G; IN_99] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[99].get_mut(&__args[..]) { 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_2: G = __r_arr[0];
         let __v_3: G = __r_arr[1];
         let __v_4: G = __r_arr[2];
@@ -12346,8 +12751,8 @@ fn aiur_fn_101(
         let __v_11: G = __r_arr[9];
         let __v_12: G = G::from_u64(7);
         let __v_13: G = G::from_u64(0);
-        let __ret: [G; OUT_101] = [__v_12, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_11];
-        record.function_queries[101].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_103] = [__v_12, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_11];
+        record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -12357,15 +12762,15 @@ fn aiur_fn_101(
   })
 }
 
-const INPUT_SIZE_102: usize = 10;
-const IN_102: usize = 10;
-const OUT_102: usize = 46;
-fn aiur_fn_102(
-  inp: [G; IN_102],
+const INPUT_SIZE_104: usize = 10;
+const IN_104: usize = 10;
+const OUT_104: usize = 46;
+fn aiur_fn_104(
+  inp: [G; IN_104],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_102], ExecError> {
+) -> Result<[G; OUT_104], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -12379,17 +12784,17 @@ fn aiur_fn_102(
     let __v_9: G = inp[9];
     match __v_0.as_canonical_u64() {
       12u64 => {
-        let __r_arr: [G; OUT_100] = { let __args: [G; IN_100] = [__v_9, __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[100].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_9, __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[102].get_mut(&__args[..]) { 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_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
         let __v_12: G = G::from_u64(8);
         let __v_13: G = G::from_u64(0);
-        let __ret: [G; OUT_102] = [__v_12, __v_10, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_11];
-        record.function_queries[102].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_104] = [__v_12, __v_10, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_11];
+        record.function_queries[104].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       13u64 => {
-        let __r_arr: [G; OUT_101] = { let __args: [G; IN_101] = [__v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[101].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[103].get_mut(&__args[..]) { 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_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
         let __v_12: G = __r_arr[2];
@@ -12436,8 +12841,8 @@ fn aiur_fn_102(
         let __v_53: G = __r_arr[43];
         let __v_54: G = __r_arr[44];
         let __v_55: G = __r_arr[45];
-        let __ret: [G; OUT_102] = [__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];
-        record.function_queries[102].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_104] = [__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];
+        record.function_queries[104].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -12447,18 +12852,18 @@ fn aiur_fn_102(
   })
 }
 
-const INPUT_SIZE_103: usize = 1;
-const IN_103: usize = 1;
-const OUT_103: usize = 49;
-fn aiur_fn_103(
-  inp: [G; IN_103],
+const INPUT_SIZE_105: usize = 1;
+const IN_105: usize = 1;
+const OUT_105: usize = 49;
+fn aiur_fn_105(
+  inp: [G; IN_105],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_103], ExecError> {
+) -> Result<[G; OUT_105], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[70].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_70] = unsafe { *(result.output.as_ptr() as *const [G; OUT_70]) }; __ret } else { aiur_fn_70(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } else { aiur_fn_72(__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];
@@ -12469,7 +12874,7 @@ fn aiur_fn_103(
     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_102] = { let __args: [G; IN_102] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[102].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[104].get_mut(&__args[..]) { 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_11: G = __r_arr[0];
     let __v_12: G = __r_arr[1];
     let __v_13: G = __r_arr[2];
@@ -12516,460 +12921,295 @@ fn aiur_fn_103(
     let __v_54: G = __r_arr[43];
     let __v_55: G = __r_arr[44];
     let __v_56: G = __r_arr[45];
-    let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { 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_57: G = __r_arr[0];
     let __v_58: G = __r_arr[1];
-    let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[86].get_mut(&__args[..]) { 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_59: G = __r_arr[0];
     let __v_60: G = __r_arr[1];
-    let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { 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 __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 !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 __ret: [G; OUT_103] = [__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_57, __v_59, __v_61, __v_62];
-    record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_105] = [__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_57, __v_59, __v_61, __v_62];
+    record.function_queries[105].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 = 1;
-fn aiur_fn_104(
-  inp: [G; IN_104],
+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_104], ExecError> {
+) -> Result<[G; OUT_106], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; 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: 9 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr };
+    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];
-    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];
     match __v_1.as_canonical_u64() {
-      0u64 => {
-        let __v_10: G = G::from_u64(0);
-        let __v_11: G = G::from_u64(0);
-        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_104] = [__v_12];
-        record.function_queries[104].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      1u64 => {
-        let __v_10: G = G::from_u64(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 !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_11: G = __r_arr[0];
-        let __v_12: G = G::from_u64(0);
-        let __v_13: G = { let __values: [G; 3] = [__v_10, __v_11, __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 __ret: [G; OUT_104] = [__v_13];
-        record.function_queries[104].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      2u64 => {
-        let __v_10: G = G::from_u64(2);
-        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 !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_11: G = __r_arr[0];
-        let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[104].get_mut(&__args[..]) { 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_12: G = __r_arr[0];
-        let __v_13: G = { let __values: [G; 3] = [__v_10, __v_11, __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 __ret: [G; OUT_104] = [__v_13];
-        record.function_queries[104].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
       3u64 => {
-        let __v_10: G = G::from_u64(3);
-        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 !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_11: G = __r_arr[0];
-        let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[104].get_mut(&__args[..]) { 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_12: G = __r_arr[0];
-        let __v_13: G = { let __values: [G; 3] = [__v_10, __v_11, __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 __ret: [G; OUT_104] = [__v_13];
-        record.function_queries[104].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      4u64 => {
-        let __v_10: G = G::from_u64(4);
-        let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } };
-        let __v_11: G = __r_arr[0];
-        let __v_12: G = G::from_u64(0);
-        let __v_13: G = { let __values: [G; 3] = [__v_10, __v_11, __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 __ret: [G; OUT_104] = [__v_13];
-        record.function_queries[104].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[106].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_106] = unsafe { *(result.output.as_ptr() as *const [G; OUT_106]) }; __ret } else { aiur_fn_106(__args, record, io_buffer, __cu)? } };
+        let __v_5: G = __r_arr[0];
+        let __v_6: G = __r_arr[1];
+        let __r_arr: [G; OUT_704] = { let __args: [G; IN_704] = [__v_6, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[704].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_704] = unsafe { *(result.output.as_ptr() as *const [G; OUT_704]) }; __ret } else { aiur_fn_704(__args, record, io_buffer, __cu)? } };
+        let __v_7: G = __r_arr[0];
+        let __ret: [G; OUT_106] = [__v_5, __v_7];
+        record.function_queries[106].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+        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_106] = [__v_0, __v_7];
+        record.function_queries[106].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 = 1;
-fn aiur_fn_105(
-  inp: [G; IN_105],
+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_105], ExecError> {
+) -> 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];
     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() {
+    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];
+    match __v_1.as_canonical_u64() {
       1u64 => {
+        let __v_11: G = G::from_u64(0);
         let __v_12: G = G::from_u64(1);
-        let __v_13: G = G::from_u64(1);
-        let __v_14: G = { let __values: [G; 3] = [__v_12, __v_13, __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 __ret: [G; OUT_105] = [__v_14];
-        record.function_queries[105].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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 = 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(1);
+        let __v_21: G = G::from_u64(1);
+        let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; 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_23: G = { let __values: [G; 10] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_22]; 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_107] = [__v_23];
+        record.function_queries[107].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } };
-        let __v_12: G = __r_arr[0];
-        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-        let __v_13: G = __r_arr[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 = G::from_u64(0);
-        let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[104].get_mut(&__args[..]) { 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_15: G = __r_arr[0];
-        let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[105].get_mut(&__args[..]) { 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_16: G = __r_arr[0];
-        let __v_17: G = { let __values: [G; 3] = [__v_14, __v_15, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_17];
-        record.function_queries[105].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_106: usize = 1;
-const IN_106: usize = 1;
-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 = G::from_u64(0);
-    let __v_2: G = G::from_u64(0);
-    let __v_3: G = G::from_u64(0);
-    let __v_4: G = G::from_u64(0);
-    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 __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { 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_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 = G::from_u64(8);
-    let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_0, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[108].get_mut(&__args[..]) { 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_19: 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_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() {
-      1u64 => {
-        let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
-        let __v_23: G = __r_arr[0];
-        match __v_23.as_canonical_u64() {
-          1u64 => {
-            let __v_24: G = G::from_u64(1);
-            let __v_25: G = G::from_u64(1);
-            let __v_26: G = { let __values: [G; 10] = [__v_24, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25]; 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_106] = [__v_26];
-            record.function_queries[106].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
+        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 __r_arr: [G; OUT_12] = { let __args: [G; IN_12] = [__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]; let __cu = unconstrained; if let Some(result) = record.function_queries[12].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_12] = unsafe { *(result.output.as_ptr() as *const [G; OUT_12]) }; __ret } else { aiur_fn_12(__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];
+        match __v_27.as_canonical_u64() {
           0u64 => {
-            let __v_24: G = G::from_u64(0);
-            let __v_25: G = G::from_u64(1);
-            let __v_26: G = G::from_u64(1);
-            let __v_27: G = { let __values: [G; 10] = [__v_25, __v_26, __v_26, __v_26, __v_26, __v_26, __v_26, __v_26, __v_26, __v_26]; 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_28: G = { let __values: [G; 10] = [__v_24, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_27]; 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_106] = [__v_28];
-            record.function_queries[106].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __v_28: G = G::from_u64(0);
+            let __v_29: G = { let __values: [G; 10] = [__v_28, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_10]; 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_107] = [__v_29];
+            record.function_queries[107].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_23.as_canonical_u64()));
+            let __v_28: G = G::from_u64(0);
+            let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { 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_29: G = __r_arr[0];
+            let __v_30: G = { let __values: [G; 10] = [__v_28, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_29]; 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_107] = [__v_30];
+            record.function_queries[107].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
           },
         }
       },
       _ => {
-        let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[106].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_106] = unsafe { *(result.output.as_ptr() as *const [G; OUT_106]) }; __ret } else { aiur_fn_106(__args, record, io_buffer, __cu)? } };
-        let __v_23: G = __r_arr[0];
-        let __v_24: G = G::from_u64(0);
-        let __v_25: G = { let __values: [G; 10] = [__v_24, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_23]; 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_106] = [__v_25];
-        record.function_queries[106].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_107: usize = 10;
-const IN_107: usize = 10;
-const OUT_107: usize = 8;
-fn aiur_fn_107(
-  inp: [G; IN_107],
+const INPUT_SIZE_108: usize = 3;
+const IN_108: usize = 3;
+const OUT_108: usize = 1;
+fn aiur_fn_108(
+  inp: [G; IN_108],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_107], ExecError> {
+) -> 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 __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() {
-      8u64 => {
-        let __ret: [G; OUT_107] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8];
-        record.function_queries[107].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_10: G = __loaded[0];
-        let __v_11: G = __loaded[1];
-        let __v_12: G = __loaded[2];
-        match __v_10.as_canonical_u64() {
-          1u64 => {
-            let __ret: [G; OUT_107] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8];
-            record.function_queries[107].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    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_3: G = __loaded[0];
+    let __v_4: G = __loaded[1];
+    let __v_5: G = __loaded[2];
+    let __v_6: G = __loaded[3];
+    let __v_7: G = __loaded[4];
+    let __v_8: G = __loaded[5];
+    let __v_9: G = __loaded[6];
+    let __v_10: G = __loaded[7];
+    let __v_11: G = __loaded[8];
+    let __v_12: G = __loaded[9];
+    match __v_3.as_canonical_u64() {
+      1u64 => {
+        match __v_2.as_canonical_u64() {
+          0u64 => {
+            let __ret: [G; OUT_108] = [__v_1];
+            record.function_queries[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
-          0u64 => {
-            match __v_9.as_canonical_u64() {
+          _ => {
+            let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { 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_13: G = __r_arr[0];
+            let __ret: [G; OUT_108] = [__v_13];
+            record.function_queries[108].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_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: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
+        let __v_13: G = __loaded[0];
+        let __v_14: G = __loaded[1];
+        let __v_15: G = __loaded[2];
+        let __v_16: G = __loaded[3];
+        let __v_17: G = __loaded[4];
+        let __v_18: G = __loaded[5];
+        let __v_19: G = __loaded[6];
+        let __v_20: G = __loaded[7];
+        let __v_21: G = __loaded[8];
+        let __v_22: G = __loaded[9];
+        match __v_13.as_canonical_u64() {
+          1u64 => {
+            match __v_2.as_canonical_u64() {
               0u64 => {
-                let __v_13: G = G::from_u64(1);
-                let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_12, __v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { 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_14: G = __r_arr[0];
-                let __v_15: G = __r_arr[1];
-                let __v_16: G = __r_arr[2];
-                let __v_17: G = __r_arr[3];
-                let __v_18: G = __r_arr[4];
-                let __v_19: G = __r_arr[5];
-                let __v_20: G = __r_arr[6];
-                let __v_21: G = __r_arr[7];
-                let __ret: [G; OUT_107] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
-                record.function_queries[107].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              1u64 => {
-                let __v_13: G = G::from_u64(2);
-                let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_12, __v_1, __v_11, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { 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_14: G = __r_arr[0];
-                let __v_15: G = __r_arr[1];
-                let __v_16: G = __r_arr[2];
-                let __v_17: G = __r_arr[3];
-                let __v_18: G = __r_arr[4];
-                let __v_19: G = __r_arr[5];
-                let __v_20: G = __r_arr[6];
-                let __v_21: G = __r_arr[7];
-                let __ret: [G; OUT_107] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
-                record.function_queries[107].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              2u64 => {
-                let __v_13: G = G::from_u64(3);
-                let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_12, __v_1, __v_2, __v_11, __v_4, __v_5, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { 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_14: G = __r_arr[0];
-                let __v_15: G = __r_arr[1];
-                let __v_16: G = __r_arr[2];
-                let __v_17: G = __r_arr[3];
-                let __v_18: G = __r_arr[4];
-                let __v_19: G = __r_arr[5];
-                let __v_20: G = __r_arr[6];
-                let __v_21: G = __r_arr[7];
-                let __ret: [G; OUT_107] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
-                record.function_queries[107].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              3u64 => {
-                let __v_13: G = G::from_u64(4);
-                let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_12, __v_1, __v_2, __v_3, __v_11, __v_5, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { 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_14: G = __r_arr[0];
-                let __v_15: G = __r_arr[1];
-                let __v_16: G = __r_arr[2];
-                let __v_17: G = __r_arr[3];
-                let __v_18: G = __r_arr[4];
-                let __v_19: G = __r_arr[5];
-                let __v_20: G = __r_arr[6];
-                let __v_21: G = __r_arr[7];
-                let __ret: [G; OUT_107] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
-                record.function_queries[107].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              4u64 => {
-                let __v_13: G = G::from_u64(5);
-                let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_11, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { 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_14: G = __r_arr[0];
-                let __v_15: G = __r_arr[1];
-                let __v_16: G = __r_arr[2];
-                let __v_17: G = __r_arr[3];
-                let __v_18: G = __r_arr[4];
-                let __v_19: G = __r_arr[5];
-                let __v_20: G = __r_arr[6];
-                let __v_21: G = __r_arr[7];
-                let __ret: [G; OUT_107] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
-                record.function_queries[107].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              5u64 => {
-                let __v_13: G = G::from_u64(6);
-                let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_11, __v_7, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { 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_14: G = __r_arr[0];
-                let __v_15: G = __r_arr[1];
-                let __v_16: G = __r_arr[2];
-                let __v_17: G = __r_arr[3];
-                let __v_18: G = __r_arr[4];
-                let __v_19: G = __r_arr[5];
-                let __v_20: G = __r_arr[6];
-                let __v_21: G = __r_arr[7];
-                let __ret: [G; OUT_107] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
-                record.function_queries[107].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              6u64 => {
-                let __v_13: G = G::from_u64(7);
-                let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_11, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { 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_14: G = __r_arr[0];
-                let __v_15: G = __r_arr[1];
-                let __v_16: G = __r_arr[2];
-                let __v_17: G = __r_arr[3];
-                let __v_18: G = __r_arr[4];
-                let __v_19: G = __r_arr[5];
-                let __v_20: G = __r_arr[6];
-                let __v_21: G = __r_arr[7];
-                let __ret: [G; OUT_107] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
-                record.function_queries[107].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_108] = [__v_0];
+                record.function_queries[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                let __v_13: G = G::from_u64(8);
-                let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_11, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { 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_14: G = __r_arr[0];
-                let __v_15: G = __r_arr[1];
-                let __v_16: G = __r_arr[2];
-                let __v_17: G = __r_arr[3];
-                let __v_18: G = __r_arr[4];
-                let __v_19: G = __r_arr[5];
-                let __v_20: G = __r_arr[6];
-                let __v_21: G = __r_arr[7];
-                let __ret: [G; OUT_107] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
-                record.function_queries[107].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { 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_23: G = __r_arr[0];
+                let __ret: [G; OUT_108] = [__v_23];
+                record.function_queries[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
+          0u64 => {
+            let __r_arr: [G; OUT_12] = { let __args: [G; IN_12] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[12].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_12] = unsafe { *(result.output.as_ptr() as *const [G; OUT_12]) }; __ret } else { aiur_fn_12(__args, record, io_buffer, __cu)? } };
+            let __v_23: G = __r_arr[0];
+            let __v_24: G = __r_arr[1];
+            let __v_25: G = __r_arr[2];
+            let __v_26: G = __r_arr[3];
+            let __v_27: G = __r_arr[4];
+            let __v_28: G = __r_arr[5];
+            let __v_29: G = __r_arr[6];
+            let __v_30: G = __r_arr[7];
+            let __v_31: G = __r_arr[8];
+            let __v_32: G = G::from_u64(0);
+            let __v_33: G = G::from_u64(0);
+            let __v_34: G = G::from_u64(0);
+            let __v_35: G = G::from_u64(0);
+            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 __r_arr: [G; OUT_12] = { let __args: [G; IN_12] = [__v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_2, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[12].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_12] = unsafe { *(result.output.as_ptr() as *const [G; OUT_12]) }; __ret } else { aiur_fn_12(__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 = (__v_31 + __v_47);
+            let __v_49: G = G::from_u64(0);
+            let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_12, __v_22, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[108].get_mut(&__args[..]) { 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_50: G = __r_arr[0];
+            let __v_51: G = { let __values: [G; 10] = [__v_49, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_50]; 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_108] = [__v_51];
+            record.function_queries[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64()));
+            return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64()));
           },
         }
       },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
+      },
     }
   })
 }
 
-const INPUT_SIZE_108: usize = 2;
-const IN_108: usize = 2;
-const OUT_108: usize = 1;
-fn aiur_fn_108(
-  inp: [G; IN_108],
+const INPUT_SIZE_109: usize = 2;
+const IN_109: usize = 2;
+const OUT_109: usize = 1;
+fn aiur_fn_109(
+  inp: [G; IN_109],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_108], ExecError> {
+) -> 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];
-    match __v_1.as_canonical_u64() {
-      0u64 => {
-        let __ret: [G; OUT_108] = [__v_0];
-        record.function_queries[108].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() {
-          1u64 => {
-            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_108] = [__v_7];
-            record.function_queries[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          0u64 => {
-            let __v_5: G = G::from_u64(1);
-            let __v_6: G = (__v_1 - __v_5);
-            let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[108].get_mut(&__args[..]) { 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_7: G = __r_arr[0];
-            let __ret: [G; OUT_108] = [__v_7];
-            record.function_queries[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-          },
-        }
-      },
-    }
+    let __v_2: G = G::from_u64(0);
+    let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[108].get_mut(&__args[..]) { 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_3: G = __r_arr[0];
+    let __ret: [G; OUT_109] = [__v_3];
+    record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_109: usize = 6;
-const IN_109: usize = 6;
-const OUT_109: usize = 1;
-fn aiur_fn_109(
-  inp: [G; IN_109],
+const INPUT_SIZE_110: usize = 16;
+const IN_110: usize = 16;
+const OUT_110: usize = 9;
+fn aiur_fn_110(
+  inp: [G; IN_110],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_109], ExecError> {
+) -> 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];
@@ -12977,365 +13217,255 @@ fn aiur_fn_109(
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
-    let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; 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: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].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];
-    let __v_13: G = __loaded[7];
-    let __v_14: G = __loaded[8];
-    let __v_15: G = __loaded[9];
-    let __v_16: G = __loaded[10];
-    let __v_17: G = __loaded[11];
-    let __v_18: G = __loaded[12];
-    let __v_19: G = __loaded[13];
-    let __v_20: G = __loaded[14];
-    let __v_21: G = __loaded[15];
-    let __v_22: G = __loaded[16];
-    let __v_23: G = __loaded[17];
-    match __v_6.as_canonical_u64() {
-      0u64 => {
-        let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__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[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } };
-        let __v_24: G = __r_arr[0];
-        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_5, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-        let __v_25: G = __r_arr[0];
-        let __v_26: G = G::from_u64(1);
-        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 !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_27: G = __r_arr[0];
-        let __v_28: G = G::from_u64(0);
-        let __v_29: G = { let __values: [G; 4] = [__v_26, __v_27, __v_28, __v_28]; 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_109] = [__v_29];
-        record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      1u64 => {
-        let __v_24: G = G::from_u64(0);
-        let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__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[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } };
-        let __v_25: G = __r_arr[0];
-        let __v_26: G = G::from_u64(0);
-        let __v_27: G = { let __values: [G; 4] = [__v_24, __v_25, __v_26, __v_26]; 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_109] = [__v_27];
-        record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      2u64 => {
-        let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__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[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } };
-        let __v_24: G = __r_arr[0];
-        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_2, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-        let __v_25: G = __r_arr[0];
-        let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_15, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[105].get_mut(&__args[..]) { 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_26: G = __r_arr[0];
-        let __v_27: G = G::from_u64(2);
-        let __v_28: G = G::from_u64(0);
-        let __v_29: G = { let __values: [G; 4] = [__v_27, __v_25, __v_26, __v_28]; 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_109] = [__v_29];
-        record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      3u64 => {
-        let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__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[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } };
-        let __v_24: G = __r_arr[0];
-        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_3, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-        let __v_25: G = __r_arr[0];
-        let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_15, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[105].get_mut(&__args[..]) { 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_26: G = __r_arr[0];
-        let __v_27: G = G::from_u64(2);
-        let __v_28: G = G::from_u64(0);
-        let __v_29: G = { let __values: [G; 4] = [__v_27, __v_25, __v_26, __v_28]; 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_109] = [__v_29];
-        record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      4u64 => {
-        let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__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[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } };
-        let __v_24: G = __r_arr[0];
-        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_2, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-        let __v_25: G = __r_arr[0];
-        let __v_26: G = G::from_u64(8);
-        let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } };
-        let __v_27: G = __r_arr[0];
-        let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_23, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[109].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_109] = unsafe { *(result.output.as_ptr() as *const [G; OUT_109]) }; __ret } else { aiur_fn_109(__args, record, io_buffer, __cu)? } };
-        let __v_28: G = __r_arr[0];
-        let __v_29: G = { let __values: [G; 4] = [__v_26, __v_25, __v_27, __v_28]; 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_109] = [__v_29];
-        record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      5u64 => {
-        let __r_arr: [G; OUT_779] = { let __args: [G; IN_779] = [__v_4, __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[779].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_779] = unsafe { *(result.output.as_ptr() as *const [G; OUT_779]) }; __ret } else { aiur_fn_779(__args, record, io_buffer, __cu)? } };
-        let __v_24: G = __r_arr[0];
-        let __v_25: G = G::from_u64(7);
-        let __v_26: G = G::from_u64(1);
-        let __v_27: G = G::from_u64(0);
-        let __v_28: G = { let __values: [G; 4] = [__v_25, __v_26, __v_24, __v_27]; 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_109] = [__v_28];
-        record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      6u64 => {
-        let __r_arr: [G; OUT_779] = { let __args: [G; IN_779] = [__v_4, __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[779].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_779] = unsafe { *(result.output.as_ptr() as *const [G; OUT_779]) }; __ret } else { aiur_fn_779(__args, record, io_buffer, __cu)? } };
-        let __v_24: G = __r_arr[0];
-        let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[106].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_106] = unsafe { *(result.output.as_ptr() as *const [G; OUT_106]) }; __ret } else { aiur_fn_106(__args, record, io_buffer, __cu)? } };
-        let __v_25: G = __r_arr[0];
-        let __v_26: G = G::from_u64(7);
-        let __v_27: G = G::from_u64(0);
-        let __v_28: G = G::from_u64(0);
-        let __v_29: G = { let __values: [G; 4] = [__v_26, __v_27, __v_25, __v_28]; 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_109] = [__v_29];
-        record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      7u64 => {
-        let __v_24: G = G::from_u64(3);
-        let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_7, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[109].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_109] = unsafe { *(result.output.as_ptr() as *const [G; OUT_109]) }; __ret } else { aiur_fn_109(__args, record, io_buffer, __cu)? } };
-        let __v_25: G = __r_arr[0];
-        let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_8, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[109].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_109] = unsafe { *(result.output.as_ptr() as *const [G; OUT_109]) }; __ret } else { aiur_fn_109(__args, record, io_buffer, __cu)? } };
-        let __v_26: G = __r_arr[0];
-        let __v_27: G = G::from_u64(0);
-        let __v_28: G = { let __values: [G; 4] = [__v_24, __v_25, __v_26, __v_27]; 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_109] = [__v_28];
-        record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      8u64 => {
-        let __v_24: G = G::from_u64(4);
-        let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_7, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[109].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_109] = unsafe { *(result.output.as_ptr() as *const [G; OUT_109]) }; __ret } else { aiur_fn_109(__args, record, io_buffer, __cu)? } };
-        let __v_25: G = __r_arr[0];
-        let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_8, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[109].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_109] = unsafe { *(result.output.as_ptr() as *const [G; OUT_109]) }; __ret } else { aiur_fn_109(__args, record, io_buffer, __cu)? } };
-        let __v_26: G = __r_arr[0];
-        let __v_27: G = G::from_u64(0);
-        let __v_28: G = { let __values: [G; 4] = [__v_24, __v_25, __v_26, __v_27]; 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_109] = [__v_28];
-        record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      9u64 => {
-        let __v_24: G = G::from_u64(5);
-        let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_7, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[109].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_109] = unsafe { *(result.output.as_ptr() as *const [G; OUT_109]) }; __ret } else { aiur_fn_109(__args, record, io_buffer, __cu)? } };
-        let __v_25: G = __r_arr[0];
-        let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_8, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[109].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_109] = unsafe { *(result.output.as_ptr() as *const [G; OUT_109]) }; __ret } else { aiur_fn_109(__args, record, io_buffer, __cu)? } };
-        let __v_26: G = __r_arr[0];
-        let __v_27: G = G::from_u64(0);
-        let __v_28: G = { let __values: [G; 4] = [__v_24, __v_25, __v_26, __v_27]; 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_109] = [__v_28];
-        record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      10u64 => {
-        let __v_24: G = G::from_u64(6);
-        let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_15, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[109].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_109] = unsafe { *(result.output.as_ptr() as *const [G; OUT_109]) }; __ret } else { aiur_fn_109(__args, record, io_buffer, __cu)? } };
-        let __v_25: G = __r_arr[0];
-        let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_16, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[109].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_109] = unsafe { *(result.output.as_ptr() as *const [G; OUT_109]) }; __ret } else { aiur_fn_109(__args, record, io_buffer, __cu)? } };
-        let __v_26: G = __r_arr[0];
-        let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_17, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[109].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_109] = unsafe { *(result.output.as_ptr() as *const [G; OUT_109]) }; __ret } else { aiur_fn_109(__args, record, io_buffer, __cu)? } };
-        let __v_27: G = __r_arr[0];
-        let __v_28: G = { let __values: [G; 4] = [__v_24, __v_25, __v_26, __v_27]; 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_109] = [__v_28];
-        record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      11u64 => {
-        let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__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[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } };
-        let __v_24: G = __r_arr[0];
-        let __r_arr: [G; OUT_796] = { let __args: [G; IN_796] = [__v_1, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[796].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_796] = unsafe { *(result.output.as_ptr() as *const [G; OUT_796]) }; __ret } else { aiur_fn_796(__args, record, io_buffer, __cu)? } };
-        let __v_25: 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_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: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-        let __v_26: G = __loaded[0];
-        let __v_27: G = __loaded[1];
-        let __v_28: G = __loaded[2];
-        match __v_26.as_canonical_u64() {
-          0u64 => {
-            let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_27, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[109].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_109] = unsafe { *(result.output.as_ptr() as *const [G; OUT_109]) }; __ret } else { aiur_fn_109(__args, record, io_buffer, __cu)? } };
-            let __v_29: G = __r_arr[0];
-            let __ret: [G; OUT_109] = [__v_29];
-            record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_26.as_canonical_u64()));
-          },
-        }
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64()));
-      },
-    }
+    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 __b2_sub: (G, G) = if unconstrained { Bytes2::sub(&__v_0, &__v_8) } else { bytes2_sub_value(__v_0, __v_8, record) };
+    let __v_16: G = __b2_sub.0;
+    let __v_17: G = __b2_sub.1;
+    let __b2_sub: (G, G) = if unconstrained { Bytes2::sub(&__v_1, &__v_9) } else { bytes2_sub_value(__v_1, __v_9, record) };
+    let __v_18: G = __b2_sub.0;
+    let __v_19: G = __b2_sub.1;
+    let __b2_sub: (G, G) = if unconstrained { Bytes2::sub(&__v_18, &__v_17) } else { bytes2_sub_value(__v_18, __v_17, record) };
+    let __v_20: G = __b2_sub.0;
+    let __v_21: G = __b2_sub.1;
+    let __v_22: G = (__v_19 + __v_21);
+    let __b2_sub: (G, G) = if unconstrained { Bytes2::sub(&__v_2, &__v_10) } else { bytes2_sub_value(__v_2, __v_10, record) };
+    let __v_23: G = __b2_sub.0;
+    let __v_24: G = __b2_sub.1;
+    let __b2_sub: (G, G) = if unconstrained { Bytes2::sub(&__v_23, &__v_22) } else { bytes2_sub_value(__v_23, __v_22, record) };
+    let __v_25: G = __b2_sub.0;
+    let __v_26: G = __b2_sub.1;
+    let __v_27: G = (__v_24 + __v_26);
+    let __b2_sub: (G, G) = if unconstrained { Bytes2::sub(&__v_3, &__v_11) } else { bytes2_sub_value(__v_3, __v_11, record) };
+    let __v_28: G = __b2_sub.0;
+    let __v_29: G = __b2_sub.1;
+    let __b2_sub: (G, G) = if unconstrained { Bytes2::sub(&__v_28, &__v_27) } else { bytes2_sub_value(__v_28, __v_27, record) };
+    let __v_30: G = __b2_sub.0;
+    let __v_31: G = __b2_sub.1;
+    let __v_32: G = (__v_29 + __v_31);
+    let __b2_sub: (G, G) = if unconstrained { Bytes2::sub(&__v_4, &__v_12) } else { bytes2_sub_value(__v_4, __v_12, record) };
+    let __v_33: G = __b2_sub.0;
+    let __v_34: G = __b2_sub.1;
+    let __b2_sub: (G, G) = if unconstrained { Bytes2::sub(&__v_33, &__v_32) } else { bytes2_sub_value(__v_33, __v_32, record) };
+    let __v_35: G = __b2_sub.0;
+    let __v_36: G = __b2_sub.1;
+    let __v_37: G = (__v_34 + __v_36);
+    let __b2_sub: (G, G) = if unconstrained { Bytes2::sub(&__v_5, &__v_13) } else { bytes2_sub_value(__v_5, __v_13, record) };
+    let __v_38: G = __b2_sub.0;
+    let __v_39: G = __b2_sub.1;
+    let __b2_sub: (G, G) = if unconstrained { Bytes2::sub(&__v_38, &__v_37) } else { bytes2_sub_value(__v_38, __v_37, record) };
+    let __v_40: G = __b2_sub.0;
+    let __v_41: G = __b2_sub.1;
+    let __v_42: G = (__v_39 + __v_41);
+    let __b2_sub: (G, G) = if unconstrained { Bytes2::sub(&__v_6, &__v_14) } else { bytes2_sub_value(__v_6, __v_14, record) };
+    let __v_43: G = __b2_sub.0;
+    let __v_44: G = __b2_sub.1;
+    let __b2_sub: (G, G) = if unconstrained { Bytes2::sub(&__v_43, &__v_42) } else { bytes2_sub_value(__v_43, __v_42, record) };
+    let __v_45: G = __b2_sub.0;
+    let __v_46: G = __b2_sub.1;
+    let __v_47: G = (__v_44 + __v_46);
+    let __b2_sub: (G, G) = if unconstrained { Bytes2::sub(&__v_7, &__v_15) } else { bytes2_sub_value(__v_7, __v_15, record) };
+    let __v_48: G = __b2_sub.0;
+    let __v_49: G = __b2_sub.1;
+    let __b2_sub: (G, G) = if unconstrained { Bytes2::sub(&__v_48, &__v_47) } else { bytes2_sub_value(__v_48, __v_47, record) };
+    let __v_50: G = __b2_sub.0;
+    let __v_51: G = __b2_sub.1;
+    let __v_52: G = (__v_49 + __v_51);
+    let __ret: [G; OUT_110] = [__v_16, __v_20, __v_25, __v_30, __v_35, __v_40, __v_45, __v_50, __v_52];
+    record.function_queries[110].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_110: usize = 7;
-const IN_110: usize = 7;
-const OUT_110: usize = 1;
-fn aiur_fn_110(
-  inp: [G; IN_110],
+const INPUT_SIZE_111: usize = 3;
+const IN_111: usize = 3;
+const OUT_111: usize = 2;
+fn aiur_fn_111(
+  inp: [G; IN_111],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_110], ExecError> {
+) -> 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 __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; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].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];
-    let __v_17: G = __loaded[10];
-    match __v_7.as_canonical_u64() {
+    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_3: G = __loaded[0];
+    let __v_4: G = __loaded[1];
+    let __v_5: G = __loaded[2];
+    let __v_6: G = __loaded[3];
+    let __v_7: G = __loaded[4];
+    let __v_8: G = __loaded[5];
+    let __v_9: G = __loaded[6];
+    let __v_10: G = __loaded[7];
+    let __v_11: G = __loaded[8];
+    let __v_12: G = __loaded[9];
+    match __v_3.as_canonical_u64() {
       1u64 => {
-        let __v_18: G = G::from_u64(1);
-        let __v_19: G = G::from_u64(1);
-        let __v_20: G = { let __values: [G; 5] = [__v_18, __v_19, __v_19, __v_19, __v_19]; 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_110] = [__v_20];
-        record.function_queries[110].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      0u64 => {
-        match __v_8.as_canonical_u64() {
-          _ => {
-            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_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_2.as_canonical_u64() {
-                  _ => {
-                    let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_16, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[109].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_109] = unsafe { *(result.output.as_ptr() as *const [G; OUT_109]) }; __ret } else { aiur_fn_109(__args, record, io_buffer, __cu)? } };
-                    let __v_21: G = __r_arr[0];
-                    let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } };
-                    let __v_22: G = __r_arr[0];
-                    let __v_23: G = G::from_u64(0);
-                    let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_17, __v_20, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[110].get_mut(&__args[..]) { 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_24: G = __r_arr[0];
-                    let __v_25: G = { let __values: [G; 5] = [__v_23, __v_19, __v_22, __v_21, __v_24]; 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_110] = [__v_25];
-                    record.function_queries[110].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_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: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
+        let __v_13: G = __loaded[0];
+        let __v_14: G = __loaded[1];
+        let __v_15: G = __loaded[2];
+        let __v_16: G = __loaded[3];
+        let __v_17: G = __loaded[4];
+        let __v_18: G = __loaded[5];
+        let __v_19: G = __loaded[6];
+        let __v_20: G = __loaded[7];
+        let __v_21: G = __loaded[8];
+        let __v_22: G = __loaded[9];
+        match __v_13.as_canonical_u64() {
+          1u64 => {
+            let __v_23: G = G::from_u64(1);
+            let __v_24: G = G::from_u64(1);
+            let __v_25: G = { let __values: [G; 10] = [__v_23, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24]; 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_111] = [__v_25, __v_2];
+            record.function_queries[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          0u64 => {
+            let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { 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_23: G = __r_arr[0];
+            match __v_23.as_canonical_u64() {
+              1u64 => {
+                let __v_24: G = G::from_u64(1);
+                let __v_25: G = G::from_u64(1);
+                let __v_26: G = { let __values: [G; 10] = [__v_24, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25]; 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_111] = [__v_26, __v_2];
+                record.function_queries[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
               },
               _ => {
-                return Err(ExecError::MatchNoCase(__v_18.as_canonical_u64()));
+                let __v_24: G = G::from_u64(1);
+                let __v_25: G = G::from_u64(1);
+                let __v_26: G = { let __values: [G; 10] = [__v_24, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25]; 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_27: G = G::from_u64(1);
+                let __ret: [G; OUT_111] = [__v_26, __v_27];
+                record.function_queries[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
               },
             }
           },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64()));
+          },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_111: usize = 18;
-const IN_111: usize = 18;
-const OUT_111: usize = 11;
-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 __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];
-    match __v_12.as_canonical_u64() {
-      _ => {
-        match __v_0.as_canonical_u64() {
-          _ => {
-            let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_10, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[109].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_109] = unsafe { *(result.output.as_ptr() as *const [G; OUT_109]) }; __ret } else { aiur_fn_109(__args, record, io_buffer, __cu)? } };
-            let __v_18: G = __r_arr[0];
-            let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[109].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_109] = unsafe { *(result.output.as_ptr() as *const [G; OUT_109]) }; __ret } else { aiur_fn_109(__args, record, io_buffer, __cu)? } };
-            let __v_19: G = __r_arr[0];
-            match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; 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: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
+        let __v_13: G = __loaded[0];
+        let __v_14: G = __loaded[1];
+        let __v_15: G = __loaded[2];
+        let __v_16: G = __loaded[3];
+        let __v_17: G = __loaded[4];
+        let __v_18: G = __loaded[5];
+        let __v_19: G = __loaded[6];
+        let __v_20: G = __loaded[7];
+        let __v_21: G = __loaded[8];
+        let __v_22: G = __loaded[9];
+        match __v_13.as_canonical_u64() {
+          1u64 => {
+            match __v_2.as_canonical_u64() {
               0u64 => {
-                let __v_20: G = G::from_u64(1);
-                let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } };
-                let __v_21: G = __r_arr[0];
-                let __v_22: G = G::from_u64(0);
-                let __ret: [G; OUT_111] = [__v_20, __v_21, __v_18, __v_19, __v_1, __v_17, __v_22, __v_22, __v_22, __v_22, __v_22];
+                let __v_23: G = G::from_u64(0);
+                let __ret: [G; OUT_111] = [__v_0, __v_23];
                 record.function_queries[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
-              1u64 => {
-                match __v_1.as_canonical_u64() {
-                  0u64 => {
-                    let __v_20: G = G::from_u64(3);
-                    let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } };
-                    let __v_21: G = __r_arr[0];
-                    let __v_22: G = G::from_u64(1);
-                    let __v_23: G = G::from_u64(0);
-                    let __ret: [G; OUT_111] = [__v_20, __v_21, __v_18, __v_19, __v_22, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23];
-                    record.function_queries[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
-                  _ => {
-                    let __v_20: G = G::from_u64(3);
-                    let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } };
-                    let __v_21: G = __r_arr[0];
-                    let __v_22: G = G::from_u64(0);
-                    let __v_23: G = G::from_u64(0);
-                    let __ret: [G; OUT_111] = [__v_20, __v_21, __v_18, __v_19, __v_22, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23];
-                    record.function_queries[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
-                }
-              },
-              2u64 => {
-                let __v_20: G = G::from_u64(2);
-                let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } };
-                let __v_21: G = __r_arr[0];
-                let __v_22: G = G::from_u64(0);
-                let __ret: [G; OUT_111] = [__v_20, __v_21, __v_18, __v_19, __v_22, __v_22, __v_22, __v_22, __v_22, __v_22, __v_22];
+              _ => {
+                let __v_23: G = G::from_u64(1);
+                let __v_24: G = G::from_u64(0);
+                let __v_25: G = G::from_u64(0);
+                let __v_26: G = G::from_u64(0);
+                let __v_27: G = G::from_u64(0);
+                let __v_28: G = G::from_u64(0);
+                let __v_29: G = G::from_u64(0);
+                let __v_30: G = G::from_u64(0);
+                let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[110].get_mut(&__args[..]) { 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_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 = G::from_u64(1);
+                let __v_41: G = G::from_u64(1);
+                let __v_42: G = { let __values: [G; 10] = [__v_40, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41]; 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_111] = { let __args: [G; IN_111] = [__v_12, __v_42, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { 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_43: G = __r_arr[0];
+                let __v_44: G = __r_arr[1];
+                let __v_45: G = G::from_u64(0);
+                let __v_46: G = { let __values: [G; 10] = [__v_45, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_43]; 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_111] = [__v_46, __v_44];
                 record.function_queries[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
-              _ => {
-                return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64()));
-              },
             }
           },
+          0u64 => {
+            let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[110].get_mut(&__args[..]) { 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_23: G = __r_arr[0];
+            let __v_24: G = __r_arr[1];
+            let __v_25: G = __r_arr[2];
+            let __v_26: G = __r_arr[3];
+            let __v_27: G = __r_arr[4];
+            let __v_28: G = __r_arr[5];
+            let __v_29: G = __r_arr[6];
+            let __v_30: G = __r_arr[7];
+            let __v_31: G = __r_arr[8];
+            let __v_32: G = G::from_u64(0);
+            let __v_33: G = G::from_u64(0);
+            let __v_34: G = G::from_u64(0);
+            let __v_35: G = G::from_u64(0);
+            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 __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_2, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[110].get_mut(&__args[..]) { 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_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 = (__v_31 + __v_47);
+            let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_12, __v_22, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { 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_49: G = __r_arr[0];
+            let __v_50: G = __r_arr[1];
+            let __v_51: G = G::from_u64(0);
+            let __v_52: G = { let __values: [G; 10] = [__v_51, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_49]; 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_111] = [__v_52, __v_50];
+            record.function_queries[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64()));
+          },
         }
       },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
+      },
     }
   })
 }
 
-const INPUT_SIZE_112: usize = 15;
-const IN_112: usize = 15;
-const OUT_112: usize = 11;
+const INPUT_SIZE_112: usize = 1;
+const IN_112: usize = 1;
+const OUT_112: usize = 0;
 fn aiur_fn_112(
   inp: [G; IN_112],
   record: &mut QueryRecord,
@@ -13344,43 +13474,43 @@ fn aiur_fn_112(
 ) -> 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 __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_10.as_canonical_u64() {
+    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_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];
+    match __v_1.as_canonical_u64() {
+      1u64 => {
+        let __ret: [G; OUT_112] = [];
+        record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      0u64 => {
+        if !unconstrained { let __vi = __v_2; let __vj = __v_3; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); 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_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); };
+        let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { 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 __ret: [G; OUT_112] = [];
+        record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
       _ => {
-        match __v_0.as_canonical_u64() {
-          _ => {
-            let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[109].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_109] = unsafe { *(result.output.as_ptr() as *const [G; OUT_109]) }; __ret } else { aiur_fn_109(__args, record, io_buffer, __cu)? } };
-            let __v_15: G = __r_arr[0];
-            let __v_16: G = G::from_u64(0);
-            let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__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[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } };
-            let __v_17: G = __r_arr[0];
-            let __v_18: G = G::from_u64(0);
-            let __ret: [G; OUT_112] = [__v_16, __v_17, __v_15, __v_0, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18];
-            record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-        }
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_113: usize = 15;
-const IN_113: usize = 15;
-const OUT_113: usize = 11;
+const INPUT_SIZE_113: usize = 1;
+const IN_113: usize = 1;
+const OUT_113: usize = 1;
 fn aiur_fn_113(
   inp: [G; IN_113],
   record: &mut QueryRecord,
@@ -13389,43 +13519,87 @@ fn aiur_fn_113(
 ) -> 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 = 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_10.as_canonical_u64() {
-      _ => {
-        match __v_0.as_canonical_u64() {
+    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_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];
+    match __v_1.as_canonical_u64() {
+      1u64 => {
+        let __v_11: G = G::from_u64(1);
+        let __v_12: G = G::from_u64(1);
+        let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; 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_113] = [__v_13];
+        record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { 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_11: G = __r_arr[0];
+        let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).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_12: G = __loaded[0];
+        let __v_13: G = __loaded[1];
+        let __v_14: G = __loaded[2];
+        let __v_15: G = __loaded[3];
+        let __v_16: G = __loaded[4];
+        let __v_17: G = __loaded[5];
+        let __v_18: G = __loaded[6];
+        let __v_19: G = __loaded[7];
+        let __v_20: G = __loaded[8];
+        let __v_21: G = __loaded[9];
+        match __v_12.as_canonical_u64() {
+          1u64 => {
+            let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } else { aiur_fn_4(__args, record, io_buffer, __cu)? } };
+            let __v_22: G = __r_arr[0];
+            match __v_22.as_canonical_u64() {
+              1u64 => {
+                let __v_23: G = G::from_u64(1);
+                let __v_24: G = G::from_u64(1);
+                let __v_25: G = { let __values: [G; 10] = [__v_23, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24]; 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_113] = [__v_25];
+                record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              0u64 => {
+                let __v_23: G = G::from_u64(0);
+                let __v_24: G = G::from_u64(1);
+                let __v_25: G = G::from_u64(1);
+                let __v_26: G = { let __values: [G; 10] = [__v_24, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25]; 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_27: G = { let __values: [G; 10] = [__v_23, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_26]; 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_113] = [__v_27];
+                record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                return Err(ExecError::MatchNoCase(__v_22.as_canonical_u64()));
+              },
+            }
+          },
           _ => {
-            let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[109].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_109] = unsafe { *(result.output.as_ptr() as *const [G; OUT_109]) }; __ret } else { aiur_fn_109(__args, record, io_buffer, __cu)? } };
-            let __v_15: G = __r_arr[0];
-            let __v_16: G = G::from_u64(4);
-            let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__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[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } };
-            let __v_17: G = __r_arr[0];
-            let __v_18: G = G::from_u64(0);
-            let __ret: [G; OUT_113] = [__v_16, __v_17, __v_15, __v_0, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18];
+            let __v_22: G = G::from_u64(0);
+            let __v_23: G = { let __values: [G; 10] = [__v_22, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11]; 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_113] = [__v_23];
             record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+      },
     }
   })
 }
 
-const INPUT_SIZE_114: usize = 51;
-const IN_114: usize = 51;
-const OUT_114: usize = 11;
+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,
@@ -13435,87 +13609,36 @@ fn aiur_fn_114(
   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];
-    match __v_44.as_canonical_u64() {
+    let __v_2: G = G::from_u64(0);
+    let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { 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_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    match __v_4.as_canonical_u64() {
+      1u64 => {
+        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_114] = [__v_7];
+        record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { 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_5: G = __r_arr[0];
+        let __ret: [G; OUT_114] = [__v_5];
+        record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
       _ => {
-        match __v_0.as_canonical_u64() {
-          _ => {
-            let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_42, __v_44, __v_45, __v_46, __v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[109].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_109] = unsafe { *(result.output.as_ptr() as *const [G; OUT_109]) }; __ret } else { aiur_fn_109(__args, record, io_buffer, __cu)? } };
-            let __v_51: G = __r_arr[0];
-            let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_43, __v_49, __v_44, __v_45, __v_46, __v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[110].get_mut(&__args[..]) { 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_52: G = __r_arr[0];
-            let __v_53: G = G::from_u64(7);
-            let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } };
-            let __v_54: G = __r_arr[0];
-            let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } };
-            let __v_55: G = __r_arr[0];
-            let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } };
-            let __v_56: G = __r_arr[0];
-            let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } };
-            let __v_57: G = __r_arr[0];
-            let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } };
-            let __v_58: G = __r_arr[0];
-            let __ret: [G; OUT_114] = [__v_53, __v_54, __v_51, __v_55, __v_56, __v_57, __v_58, __v_52, __v_0, __v_1, __v_50];
-            record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-        }
+        return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_115: usize = 34;
-const IN_115: usize = 34;
-const OUT_115: usize = 11;
+const INPUT_SIZE_115: usize = 2;
+const IN_115: usize = 2;
+const OUT_115: usize = 1;
 fn aiur_fn_115(
   inp: [G; IN_115],
   record: &mut QueryRecord,
@@ -13525,65 +13648,39 @@ fn aiur_fn_115(
   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() {
+    let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } };
+    let __v_2: G = __r_arr[0];
+    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_3: G = __loaded[0];
+    let __v_4: G = __loaded[1];
+    let __v_5: G = __loaded[2];
+    let __v_6: G = __loaded[3];
+    let __v_7: G = __loaded[4];
+    let __v_8: G = __loaded[5];
+    let __v_9: G = __loaded[6];
+    let __v_10: G = __loaded[7];
+    let __v_11: G = __loaded[8];
+    let __v_12: G = __loaded[9];
+    match __v_3.as_canonical_u64() {
+      1u64 => {
+        let __v_13: G = G::from_u64(1);
+        let __ret: [G; OUT_115] = [__v_13];
+        record.function_queries[115].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
       _ => {
-        match __v_0.as_canonical_u64() {
-          _ => {
-            let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_25, __v_27, __v_28, __v_29, __v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[109].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_109] = unsafe { *(result.output.as_ptr() as *const [G; OUT_109]) }; __ret } else { aiur_fn_109(__args, record, io_buffer, __cu)? } };
-            let __v_34: G = __r_arr[0];
-            let __v_35: G = G::from_u64(5);
-            let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__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[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } };
-            let __v_36: G = __r_arr[0];
-            let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__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[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } };
-            let __v_37: G = __r_arr[0];
-            let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__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[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } };
-            let __v_38: G = __r_arr[0];
-            let __v_39: G = G::from_u64(0);
-            let __ret: [G; OUT_115] = [__v_35, __v_36, __v_34, __v_37, __v_38, __v_32, __v_0, __v_33, __v_39, __v_39, __v_39];
-            record.function_queries[115].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-        }
+        let __v_13: G = G::from_u64(0);
+        let __ret: [G; OUT_115] = [__v_13];
+        record.function_queries[115].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_116: usize = 40;
-const IN_116: usize = 40;
-const OUT_116: usize = 11;
+const INPUT_SIZE_116: usize = 1;
+const IN_116: usize = 1;
+const OUT_116: usize = 1;
 fn aiur_fn_116(
   inp: [G; IN_116],
   record: &mut QueryRecord,
@@ -13592,74 +13689,30 @@ fn aiur_fn_116(
 ) -> 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 __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];
-    match __v_34.as_canonical_u64() {
-      _ => {
-        match __v_0.as_canonical_u64() {
-          _ => {
-            let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_33, __v_34, __v_35, __v_36, __v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[109].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_109] = unsafe { *(result.output.as_ptr() as *const [G; OUT_109]) }; __ret } else { aiur_fn_109(__args, record, io_buffer, __cu)? } };
-            let __v_40: G = __r_arr[0];
-            let __v_41: G = G::from_u64(6);
-            let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__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[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } };
-            let __v_42: G = __r_arr[0];
-            let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__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[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } };
-            let __v_43: G = __r_arr[0];
-            let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__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[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } };
-            let __v_44: G = __r_arr[0];
-            let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__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[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } };
-            let __v_45: G = __r_arr[0];
-            let __v_46: G = G::from_u64(0);
-            let __ret: [G; OUT_116] = [__v_41, __v_42, __v_40, __v_39, __v_43, __v_44, __v_45, __v_0, __v_46, __v_46, __v_46];
-            record.function_queries[116].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-        }
-      },
-    }
+    let __v_1: G = G::from_u64(0);
+    let __v_2: G = G::from_u64(1);
+    let __v_3: G = G::from_u64(0);
+    let __v_4: G = G::from_u64(0);
+    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(1);
+    let __v_11: G = G::from_u64(1);
+    let __v_12: G = { let __values: [G; 10] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; 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_13: G = { let __values: [G; 10] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12]; 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_114] = { let __args: [G; IN_114] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } };
+    let __v_14: G = __r_arr[0];
+    let __ret: [G; OUT_116] = [__v_14];
+    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 = 11;
+const INPUT_SIZE_117: usize = 2;
+const IN_117: usize = 2;
+const OUT_117: usize = 2;
 fn aiur_fn_117(
   inp: [G; IN_117],
   record: &mut QueryRecord,
@@ -13668,168 +13721,29 @@ fn aiur_fn_117(
 ) -> Result<[G; OUT_117], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __loaded: [G; 52] = { let __mq = record.memory_queries.get_mut(&52).ok_or(ExecError::InvalidMemorySize(52))?; 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: 52 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 52] = __args[..52].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 __v_35: G = __loaded[34];
-    let __v_36: G = __loaded[35];
-    let __v_37: G = __loaded[36];
-    let __v_38: G = __loaded[37];
-    let __v_39: G = __loaded[38];
-    let __v_40: G = __loaded[39];
-    let __v_41: G = __loaded[40];
-    let __v_42: G = __loaded[41];
-    let __v_43: G = __loaded[42];
-    let __v_44: G = __loaded[43];
-    let __v_45: G = __loaded[44];
-    let __v_46: G = __loaded[45];
-    let __v_47: G = __loaded[46];
-    let __v_48: G = __loaded[47];
-    let __v_49: G = __loaded[48];
-    let __v_50: G = __loaded[49];
-    let __v_51: G = __loaded[50];
-    let __v_52: G = __loaded[51];
-    match __v_1.as_canonical_u64() {
+    let __v_1: G = inp[1];
+    let __v_2: G = G::from_u64(256);
+    let __v_3: G = { let __a_val = __v_0.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_3.as_canonical_u64() {
+      1u64 => {
+        let __ret: [G; OUT_117] = [__v_0, __v_1];
+        record.function_queries[117].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __v_4: G = G::from_u64(256);
+        let __v_5: G = (__v_0 - __v_4);
+        let __v_6: G = G::from_u64(1);
+        let __v_7: G = (__v_1 + __v_6);
+        let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[117].get_mut(&__args[..]) { 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_8: G = __r_arr[0];
+        let __v_9: G = __r_arr[1];
+        let __ret: [G; OUT_117] = [__v_8, __v_9];
+        record.function_queries[117].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
       _ => {
-        match __v_6.as_canonical_u64() {
-          0u64 => {
-            let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__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_1, __v_2, __v_3, __v_4, __v_5, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { 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_53: G = __r_arr[0];
-            let __v_54: G = __r_arr[1];
-            let __v_55: G = __r_arr[2];
-            let __v_56: G = __r_arr[3];
-            let __v_57: G = __r_arr[4];
-            let __v_58: G = __r_arr[5];
-            let __v_59: G = __r_arr[6];
-            let __v_60: G = __r_arr[7];
-            let __v_61: G = __r_arr[8];
-            let __v_62: G = __r_arr[9];
-            let __v_63: G = __r_arr[10];
-            let __ret: [G; OUT_117] = [__v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63];
-            record.function_queries[117].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          1u64 => {
-            let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { 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_53: G = __r_arr[0];
-            let __v_54: G = __r_arr[1];
-            let __v_55: G = __r_arr[2];
-            let __v_56: G = __r_arr[3];
-            let __v_57: G = __r_arr[4];
-            let __v_58: G = __r_arr[5];
-            let __v_59: G = __r_arr[6];
-            let __v_60: G = __r_arr[7];
-            let __v_61: G = __r_arr[8];
-            let __v_62: G = __r_arr[9];
-            let __v_63: G = __r_arr[10];
-            let __ret: [G; OUT_117] = [__v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63];
-            record.function_queries[117].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          2u64 => {
-            let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { 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_53: G = __r_arr[0];
-            let __v_54: G = __r_arr[1];
-            let __v_55: G = __r_arr[2];
-            let __v_56: G = __r_arr[3];
-            let __v_57: G = __r_arr[4];
-            let __v_58: G = __r_arr[5];
-            let __v_59: G = __r_arr[6];
-            let __v_60: G = __r_arr[7];
-            let __v_61: G = __r_arr[8];
-            let __v_62: G = __r_arr[9];
-            let __v_63: G = __r_arr[10];
-            let __ret: [G; OUT_117] = [__v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63];
-            record.function_queries[117].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          3u64 => {
-            let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__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, __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_1, __v_2, __v_3, __v_4, __v_5, __v_51, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } };
-            let __v_53: G = __r_arr[0];
-            let __v_54: G = __r_arr[1];
-            let __v_55: G = __r_arr[2];
-            let __v_56: G = __r_arr[3];
-            let __v_57: G = __r_arr[4];
-            let __v_58: G = __r_arr[5];
-            let __v_59: G = __r_arr[6];
-            let __v_60: G = __r_arr[7];
-            let __v_61: G = __r_arr[8];
-            let __v_62: G = __r_arr[9];
-            let __v_63: G = __r_arr[10];
-            let __ret: [G; OUT_117] = [__v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63];
-            record.function_queries[117].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          4u64 => {
-            let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__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_1, __v_2, __v_3, __v_4, __v_5, __v_34, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { 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_53: G = __r_arr[0];
-            let __v_54: G = __r_arr[1];
-            let __v_55: G = __r_arr[2];
-            let __v_56: G = __r_arr[3];
-            let __v_57: G = __r_arr[4];
-            let __v_58: G = __r_arr[5];
-            let __v_59: G = __r_arr[6];
-            let __v_60: G = __r_arr[7];
-            let __v_61: G = __r_arr[8];
-            let __v_62: G = __r_arr[9];
-            let __v_63: G = __r_arr[10];
-            let __ret: [G; OUT_117] = [__v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63];
-            record.function_queries[117].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          5u64 => {
-            let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__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, __v_37, __v_38, __v_39, __v_40, __v_1, __v_2, __v_3, __v_4, __v_5, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { 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_53: G = __r_arr[0];
-            let __v_54: G = __r_arr[1];
-            let __v_55: G = __r_arr[2];
-            let __v_56: G = __r_arr[3];
-            let __v_57: G = __r_arr[4];
-            let __v_58: G = __r_arr[5];
-            let __v_59: G = __r_arr[6];
-            let __v_60: G = __r_arr[7];
-            let __v_61: G = __r_arr[8];
-            let __v_62: G = __r_arr[9];
-            let __v_63: G = __r_arr[10];
-            let __ret: [G; OUT_117] = [__v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63];
-            record.function_queries[117].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()));
       },
     }
   })
@@ -13837,7 +13751,7 @@ fn aiur_fn_117(
 
 const INPUT_SIZE_118: usize = 1;
 const IN_118: usize = 1;
-const OUT_118: usize = 1;
+const OUT_118: usize = 3;
 fn aiur_fn_118(
   inp: [G; IN_118],
   record: &mut QueryRecord,
@@ -13846,846 +13760,29 @@ fn aiur_fn_118(
 ) -> Result<[G; OUT_118], 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(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_118] = [__v_6];
-        record.function_queries[118].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[117].get_mut(&__args[..]) { 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_4: G = __r_arr[0];
-        let __v_5: G = __r_arr[1];
-        let __v_6: G = __r_arr[2];
-        let __v_7: G = __r_arr[3];
-        let __v_8: G = __r_arr[4];
-        let __v_9: G = __r_arr[5];
-        let __v_10: G = __r_arr[6];
-        let __v_11: G = __r_arr[7];
-        let __v_12: G = __r_arr[8];
-        let __v_13: G = __r_arr[9];
-        let __v_14: G = __r_arr[10];
-        let __v_15: G = G::from_u64(0);
-        let __v_16: G = { let __values: [G; 11] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_118] = { let __args: [G; IN_118] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { 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_17: G = __r_arr[0];
-        let __v_18: G = { let __values: [G; 3] = [__v_15, __v_16, __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 __ret: [G; OUT_118] = [__v_18];
-        record.function_queries[118].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
-      },
-    }
+    let __v_1: G = G::from_u64(0);
+    let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[117].get_mut(&__args[..]) { 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_2: G = __r_arr[0];
+    let __v_3: G = __r_arr[1];
+    let __v_4: G = G::from_u64(0);
+    let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[117].get_mut(&__args[..]) { 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 __v_6: G = __r_arr[1];
+    let __ret: [G; OUT_118] = [__v_2, __v_5, __v_6];
+    record.function_queries[118].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_119: usize = 1;
-const IN_119: usize = 1;
-const OUT_119: usize = 48;
+const INPUT_SIZE_119: usize = 16;
+const IN_119: usize = 16;
+const OUT_119: usize = 16;
 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 __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_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 = G::from_u64(2);
-    let __io_pair: (G, G) = { let __key: [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 __info = io_buffer.get_info(__v_33, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) };
-    let __v_34: G = __io_pair.0;
-    let __v_35: G = __io_pair.1;
-    let __v_36: G = G::from_u64(2);
-    let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_36, __v_34, __v_35]; let __cu = true; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { let __ret: [G; OUT_0] = unsafe { *(result.output.as_ptr() as *const [G; OUT_0]) }; __ret } else { aiur_fn_0(__args, record, io_buffer, __cu)? } };
-    let __v_37: G = __r_arr[0];
-    let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_37, __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[15].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } else { aiur_fn_15(__args, record, io_buffer, __cu)? } };
-    let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[103].get_mut(&__args[..]) { 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_38: G = __r_arr[0];
-    let __v_39: G = __r_arr[1];
-    let __v_40: G = __r_arr[2];
-    let __v_41: G = __r_arr[3];
-    let __v_42: G = __r_arr[4];
-    let __v_43: G = __r_arr[5];
-    let __v_44: G = __r_arr[6];
-    let __v_45: G = __r_arr[7];
-    let __v_46: G = __r_arr[8];
-    let __v_47: G = __r_arr[9];
-    let __v_48: G = __r_arr[10];
-    let __v_49: G = __r_arr[11];
-    let __v_50: G = __r_arr[12];
-    let __v_51: G = __r_arr[13];
-    let __v_52: G = __r_arr[14];
-    let __v_53: G = __r_arr[15];
-    let __v_54: G = __r_arr[16];
-    let __v_55: G = __r_arr[17];
-    let __v_56: G = __r_arr[18];
-    let __v_57: G = __r_arr[19];
-    let __v_58: G = __r_arr[20];
-    let __v_59: G = __r_arr[21];
-    let __v_60: G = __r_arr[22];
-    let __v_61: G = __r_arr[23];
-    let __v_62: G = __r_arr[24];
-    let __v_63: G = __r_arr[25];
-    let __v_64: G = __r_arr[26];
-    let __v_65: G = __r_arr[27];
-    let __v_66: G = __r_arr[28];
-    let __v_67: G = __r_arr[29];
-    let __v_68: G = __r_arr[30];
-    let __v_69: G = __r_arr[31];
-    let __v_70: G = __r_arr[32];
-    let __v_71: G = __r_arr[33];
-    let __v_72: G = __r_arr[34];
-    let __v_73: G = __r_arr[35];
-    let __v_74: G = __r_arr[36];
-    let __v_75: G = __r_arr[37];
-    let __v_76: G = __r_arr[38];
-    let __v_77: G = __r_arr[39];
-    let __v_78: G = __r_arr[40];
-    let __v_79: G = __r_arr[41];
-    let __v_80: G = __r_arr[42];
-    let __v_81: G = __r_arr[43];
-    let __v_82: G = __r_arr[44];
-    let __v_83: G = __r_arr[45];
-    let __v_84: G = __r_arr[46];
-    let __v_85: G = __r_arr[47];
-    let __v_86: G = __r_arr[48];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_86.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).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_87: G = __loaded[0];
-    let __v_88: G = __loaded[1];
-    let __v_89: G = __loaded[2];
-    let __v_90: G = G::from_u64(1);
-    let __v_91: G = G::from_u64(1);
-    if (__v_87 != __v_90) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_87.as_canonical_u64(), rhs: __v_90.as_canonical_u64() });
-    }
-    if (__v_88 != __v_91) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_88.as_canonical_u64(), rhs: __v_91.as_canonical_u64() });
-    }
-    if (__v_89 != __v_91) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_89.as_canonical_u64(), rhs: __v_91.as_canonical_u64() });
-    }
-    let __ret: [G; OUT_119] = [__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];
-    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 = 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 __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_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 = G::from_u64(5);
-    let __io_pair: (G, G) = { let __key: [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 __info = io_buffer.get_info(__v_33, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) };
-    let __v_34: G = __io_pair.0;
-    let __v_35: G = __io_pair.1;
-    let __v_36: G = G::from_u64(5);
-    let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_36, __v_34, __v_35]; let __cu = true; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { let __ret: [G; OUT_0] = unsafe { *(result.output.as_ptr() as *const [G; OUT_0]) }; __ret } else { aiur_fn_0(__args, record, io_buffer, __cu)? } };
-    let __v_37: G = __r_arr[0];
-    let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_37, __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[15].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } else { aiur_fn_15(__args, record, io_buffer, __cu)? } };
-    let __ret: [G; OUT_120] = [__v_37];
-    record.function_queries[120].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_121: usize = 2;
-const IN_121: usize = 2;
-const OUT_121: usize = 1;
-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 __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_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];
-    let __v_12: G = __loaded[10];
-    let __v_13: G = __loaded[11];
-    let __v_14: G = __loaded[12];
-    let __v_15: G = __loaded[13];
-    let __v_16: G = __loaded[14];
-    let __v_17: G = __loaded[15];
-    let __v_18: G = __loaded[16];
-    let __v_19: G = __loaded[17];
-    let __v_20: G = __loaded[18];
-    let __v_21: G = __loaded[19];
-    let __v_22: G = __loaded[20];
-    let __v_23: G = __loaded[21];
-    let __v_24: G = __loaded[22];
-    let __v_25: G = __loaded[23];
-    let __v_26: G = __loaded[24];
-    let __v_27: G = __loaded[25];
-    let __v_28: G = __loaded[26];
-    let __v_29: G = __loaded[27];
-    let __v_30: G = __loaded[28];
-    let __v_31: G = __loaded[29];
-    let __v_32: G = __loaded[30];
-    let __v_33: 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_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 = (__v_3 - __v_35);
-    let __v_67: G = (__v_4 - __v_36);
-    let __v_68: G = (__v_5 - __v_37);
-    let __v_69: G = (__v_6 - __v_38);
-    let __v_70: G = (__v_7 - __v_39);
-    let __v_71: G = (__v_8 - __v_40);
-    let __v_72: G = (__v_9 - __v_41);
-    let __v_73: G = (__v_10 - __v_42);
-    let __v_74: G = (__v_11 - __v_43);
-    let __v_75: G = (__v_12 - __v_44);
-    let __v_76: G = (__v_13 - __v_45);
-    let __v_77: G = (__v_14 - __v_46);
-    let __v_78: G = (__v_15 - __v_47);
-    let __v_79: G = (__v_16 - __v_48);
-    let __v_80: G = (__v_17 - __v_49);
-    let __v_81: G = (__v_18 - __v_50);
-    let __v_82: G = (__v_19 - __v_51);
-    let __v_83: G = (__v_20 - __v_52);
-    let __v_84: G = (__v_21 - __v_53);
-    let __v_85: G = (__v_22 - __v_54);
-    let __v_86: G = (__v_23 - __v_55);
-    let __v_87: G = (__v_24 - __v_56);
-    let __v_88: G = (__v_25 - __v_57);
-    let __v_89: G = (__v_26 - __v_58);
-    let __v_90: G = (__v_27 - __v_59);
-    let __v_91: G = (__v_28 - __v_60);
-    let __v_92: G = (__v_29 - __v_61);
-    let __v_93: G = (__v_30 - __v_62);
-    let __v_94: G = (__v_31 - __v_63);
-    let __v_95: G = (__v_32 - __v_64);
-    let __v_96: G = (__v_33 - __v_65);
-    match __v_66.as_canonical_u64() {
-      0u64 => {
-        match __v_67.as_canonical_u64() {
-          0u64 => {
-            match __v_68.as_canonical_u64() {
-              0u64 => {
-                match __v_69.as_canonical_u64() {
-                  0u64 => {
-                    match __v_70.as_canonical_u64() {
-                      0u64 => {
-                        match __v_71.as_canonical_u64() {
-                          0u64 => {
-                            match __v_72.as_canonical_u64() {
-                              0u64 => {
-                                match __v_73.as_canonical_u64() {
-                                  0u64 => {
-                                    match __v_74.as_canonical_u64() {
-                                      0u64 => {
-                                        match __v_75.as_canonical_u64() {
-                                          0u64 => {
-                                            match __v_76.as_canonical_u64() {
-                                              0u64 => {
-                                                match __v_77.as_canonical_u64() {
-                                                  0u64 => {
-                                                    match __v_78.as_canonical_u64() {
-                                                      0u64 => {
-                                                        match __v_79.as_canonical_u64() {
-                                                          0u64 => {
-                                                            match __v_80.as_canonical_u64() {
-                                                              0u64 => {
-                                                                match __v_81.as_canonical_u64() {
-                                                                  0u64 => {
-                                                                    match __v_82.as_canonical_u64() {
-                                                                      0u64 => {
-                                                                        match __v_83.as_canonical_u64() {
-                                                                          0u64 => {
-                                                                            match __v_84.as_canonical_u64() {
-                                                                              0u64 => {
-                                                                                match __v_85.as_canonical_u64() {
-                                                                                  0u64 => {
-                                                                                    match __v_86.as_canonical_u64() {
-                                                                                      0u64 => {
-                                                                                        match __v_87.as_canonical_u64() {
-                                                                                          0u64 => {
-                                                                                            match __v_88.as_canonical_u64() {
-                                                                                              0u64 => {
-                                                                                                match __v_89.as_canonical_u64() {
-                                                                                                  0u64 => {
-                                                                                                    match __v_90.as_canonical_u64() {
-                                                                                                      0u64 => {
-                                                                                                        match __v_91.as_canonical_u64() {
-                                                                                                          0u64 => {
-                                                                                                            match __v_92.as_canonical_u64() {
-                                                                                                              0u64 => {
-                                                                                                                match __v_93.as_canonical_u64() {
-                                                                                                                  0u64 => {
-                                                                                                                    match __v_94.as_canonical_u64() {
-                                                                                                                      0u64 => {
-                                                                                                                        match __v_95.as_canonical_u64() {
-                                                                                                                          0u64 => {
-                                                                                                                            match __v_96.as_canonical_u64() {
-                                                                                                                              0u64 => {
-                                                                                                                                let __v_97: G = G::from_u64(1);
-                                                                                                                                let __ret: [G; OUT_121] = [__v_97];
-                                                                                                                                record.function_queries[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                                                                                                                return Ok(__ret);
-                                                                                                                              },
-                                                                                                                              _ => {
-                                                                                                                                let __v_97: G = G::from_u64(0);
-                                                                                                                                let __ret: [G; OUT_121] = [__v_97];
-                                                                                                                                record.function_queries[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                                                                                                                return Ok(__ret);
-                                                                                                                              },
-                                                                                                                            }
-                                                                                                                          },
-                                                                                                                          _ => {
-                                                                                                                            let __v_97: G = G::from_u64(0);
-                                                                                                                            let __ret: [G; OUT_121] = [__v_97];
-                                                                                                                            record.function_queries[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                                                                                                            return Ok(__ret);
-                                                                                                                          },
-                                                                                                                        }
-                                                                                                                      },
-                                                                                                                      _ => {
-                                                                                                                        let __v_97: G = G::from_u64(0);
-                                                                                                                        let __ret: [G; OUT_121] = [__v_97];
-                                                                                                                        record.function_queries[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                                                                                                        return Ok(__ret);
-                                                                                                                      },
-                                                                                                                    }
-                                                                                                                  },
-                                                                                                                  _ => {
-                                                                                                                    let __v_97: G = G::from_u64(0);
-                                                                                                                    let __ret: [G; OUT_121] = [__v_97];
-                                                                                                                    record.function_queries[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                                                                                                    return Ok(__ret);
-                                                                                                                  },
-                                                                                                                }
-                                                                                                              },
-                                                                                                              _ => {
-                                                                                                                let __v_97: G = G::from_u64(0);
-                                                                                                                let __ret: [G; OUT_121] = [__v_97];
-                                                                                                                record.function_queries[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                                                                                                return Ok(__ret);
-                                                                                                              },
-                                                                                                            }
-                                                                                                          },
-                                                                                                          _ => {
-                                                                                                            let __v_97: G = G::from_u64(0);
-                                                                                                            let __ret: [G; OUT_121] = [__v_97];
-                                                                                                            record.function_queries[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                                                                                            return Ok(__ret);
-                                                                                                          },
-                                                                                                        }
-                                                                                                      },
-                                                                                                      _ => {
-                                                                                                        let __v_97: G = G::from_u64(0);
-                                                                                                        let __ret: [G; OUT_121] = [__v_97];
-                                                                                                        record.function_queries[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                                                                                        return Ok(__ret);
-                                                                                                      },
-                                                                                                    }
-                                                                                                  },
-                                                                                                  _ => {
-                                                                                                    let __v_97: G = G::from_u64(0);
-                                                                                                    let __ret: [G; OUT_121] = [__v_97];
-                                                                                                    record.function_queries[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                                                                                    return Ok(__ret);
-                                                                                                  },
-                                                                                                }
-                                                                                              },
-                                                                                              _ => {
-                                                                                                let __v_97: G = G::from_u64(0);
-                                                                                                let __ret: [G; OUT_121] = [__v_97];
-                                                                                                record.function_queries[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                                                                                return Ok(__ret);
-                                                                                              },
-                                                                                            }
-                                                                                          },
-                                                                                          _ => {
-                                                                                            let __v_97: G = G::from_u64(0);
-                                                                                            let __ret: [G; OUT_121] = [__v_97];
-                                                                                            record.function_queries[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                                                                            return Ok(__ret);
-                                                                                          },
-                                                                                        }
-                                                                                      },
-                                                                                      _ => {
-                                                                                        let __v_97: G = G::from_u64(0);
-                                                                                        let __ret: [G; OUT_121] = [__v_97];
-                                                                                        record.function_queries[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                                                                        return Ok(__ret);
-                                                                                      },
-                                                                                    }
-                                                                                  },
-                                                                                  _ => {
-                                                                                    let __v_97: G = G::from_u64(0);
-                                                                                    let __ret: [G; OUT_121] = [__v_97];
-                                                                                    record.function_queries[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                                                                    return Ok(__ret);
-                                                                                  },
-                                                                                }
-                                                                              },
-                                                                              _ => {
-                                                                                let __v_97: G = G::from_u64(0);
-                                                                                let __ret: [G; OUT_121] = [__v_97];
-                                                                                record.function_queries[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                                                                return Ok(__ret);
-                                                                              },
-                                                                            }
-                                                                          },
-                                                                          _ => {
-                                                                            let __v_97: G = G::from_u64(0);
-                                                                            let __ret: [G; OUT_121] = [__v_97];
-                                                                            record.function_queries[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                                                            return Ok(__ret);
-                                                                          },
-                                                                        }
-                                                                      },
-                                                                      _ => {
-                                                                        let __v_97: G = G::from_u64(0);
-                                                                        let __ret: [G; OUT_121] = [__v_97];
-                                                                        record.function_queries[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                                                        return Ok(__ret);
-                                                                      },
-                                                                    }
-                                                                  },
-                                                                  _ => {
-                                                                    let __v_97: G = G::from_u64(0);
-                                                                    let __ret: [G; OUT_121] = [__v_97];
-                                                                    record.function_queries[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                                                    return Ok(__ret);
-                                                                  },
-                                                                }
-                                                              },
-                                                              _ => {
-                                                                let __v_97: G = G::from_u64(0);
-                                                                let __ret: [G; OUT_121] = [__v_97];
-                                                                record.function_queries[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                                                return Ok(__ret);
-                                                              },
-                                                            }
-                                                          },
-                                                          _ => {
-                                                            let __v_97: G = G::from_u64(0);
-                                                            let __ret: [G; OUT_121] = [__v_97];
-                                                            record.function_queries[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                                            return Ok(__ret);
-                                                          },
-                                                        }
-                                                      },
-                                                      _ => {
-                                                        let __v_97: G = G::from_u64(0);
-                                                        let __ret: [G; OUT_121] = [__v_97];
-                                                        record.function_queries[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                                        return Ok(__ret);
-                                                      },
-                                                    }
-                                                  },
-                                                  _ => {
-                                                    let __v_97: G = G::from_u64(0);
-                                                    let __ret: [G; OUT_121] = [__v_97];
-                                                    record.function_queries[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                                    return Ok(__ret);
-                                                  },
-                                                }
-                                              },
-                                              _ => {
-                                                let __v_97: G = G::from_u64(0);
-                                                let __ret: [G; OUT_121] = [__v_97];
-                                                record.function_queries[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                                return Ok(__ret);
-                                              },
-                                            }
-                                          },
-                                          _ => {
-                                            let __v_97: G = G::from_u64(0);
-                                            let __ret: [G; OUT_121] = [__v_97];
-                                            record.function_queries[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                            return Ok(__ret);
-                                          },
-                                        }
-                                      },
-                                      _ => {
-                                        let __v_97: G = G::from_u64(0);
-                                        let __ret: [G; OUT_121] = [__v_97];
-                                        record.function_queries[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                        return Ok(__ret);
-                                      },
-                                    }
-                                  },
-                                  _ => {
-                                    let __v_97: G = G::from_u64(0);
-                                    let __ret: [G; OUT_121] = [__v_97];
-                                    record.function_queries[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                    return Ok(__ret);
-                                  },
-                                }
-                              },
-                              _ => {
-                                let __v_97: G = G::from_u64(0);
-                                let __ret: [G; OUT_121] = [__v_97];
-                                record.function_queries[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                return Ok(__ret);
-                              },
-                            }
-                          },
-                          _ => {
-                            let __v_97: G = G::from_u64(0);
-                            let __ret: [G; OUT_121] = [__v_97];
-                            record.function_queries[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                            return Ok(__ret);
-                          },
-                        }
-                      },
-                      _ => {
-                        let __v_97: G = G::from_u64(0);
-                        let __ret: [G; OUT_121] = [__v_97];
-                        record.function_queries[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                        return Ok(__ret);
-                      },
-                    }
-                  },
-                  _ => {
-                    let __v_97: G = G::from_u64(0);
-                    let __ret: [G; OUT_121] = [__v_97];
-                    record.function_queries[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
-                }
-              },
-              _ => {
-                let __v_97: G = G::from_u64(0);
-                let __ret: [G; OUT_121] = [__v_97];
-                record.function_queries[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-            }
-          },
-          _ => {
-            let __v_97: G = G::from_u64(0);
-            let __ret: [G; OUT_121] = [__v_97];
-            record.function_queries[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-        }
-      },
-      _ => {
-        let __v_97: G = G::from_u64(0);
-        let __ret: [G; OUT_121] = [__v_97];
-        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 = 1;
-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 __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_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];
-    let __v_12: G = __loaded[10];
-    let __v_13: G = __loaded[11];
-    let __v_14: G = __loaded[12];
-    let __v_15: G = __loaded[13];
-    let __v_16: G = __loaded[14];
-    let __v_17: G = __loaded[15];
-    let __v_18: G = __loaded[16];
-    let __v_19: G = __loaded[17];
-    let __v_20: G = __loaded[18];
-    let __v_21: G = __loaded[19];
-    let __v_22: G = __loaded[20];
-    let __v_23: G = __loaded[21];
-    let __v_24: G = __loaded[22];
-    let __v_25: G = __loaded[23];
-    let __v_26: G = __loaded[24];
-    let __v_27: G = __loaded[25];
-    let __v_28: G = __loaded[26];
-    let __v_29: G = __loaded[27];
-    let __v_30: G = __loaded[28];
-    let __v_31: G = __loaded[29];
-    let __v_32: G = __loaded[30];
-    let __v_33: 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_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 = (__v_2 - __v_34);
-    match __v_66.as_canonical_u64() {
-      0u64 => {
-        let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { 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_67: G = __r_arr[0];
-        let __ret: [G; OUT_122] = [__v_67];
-        record.function_queries[122].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        let __v_67: G = G::from_u64(0);
-        let __ret: [G; OUT_122] = [__v_67];
-        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 = 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 __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_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 = G::from_u64(3);
-    let __io_pair: (G, G) = { let __key: [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 __info = io_buffer.get_info(__v_33, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) };
-    let __v_34: G = __io_pair.0;
-    let __v_35: G = __io_pair.1;
-    let __v_36: G = G::from_u64(3);
-    let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_36, __v_34, __v_35]; let __cu = true; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { let __ret: [G; OUT_0] = unsafe { *(result.output.as_ptr() as *const [G; OUT_0]) }; __ret } else { aiur_fn_0(__args, record, io_buffer, __cu)? } };
-    let __v_37: 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_37.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).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_38: G = __loaded[0];
-    let __v_39: G = __loaded[1];
-    let __v_40: G = __loaded[2];
-    match __v_38.as_canonical_u64() {
-      0u64 => {
-        let __ret: [G; OUT_123] = [__v_39];
-        record.function_queries[123].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_38.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_124: usize = 0;
-const IN_124: usize = 0;
-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 = G::from_u64(4294967295);
-    let __ret: [G; OUT_124] = [__v_0];
-    record.function_queries[124].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_125: usize = 45;
-const IN_125: usize = 45;
-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];
@@ -14703,11248 +13800,2356 @@ fn aiur_fn_125(
     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];
-    match __v_0.as_canonical_u64() {
-      6u64 => {
-        match __v_1.as_canonical_u64() {
-          _ => {
-            let __ret: [G; OUT_125] = [__v_9];
-            record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-        }
-      },
-      4u64 => {
-        match __v_1.as_canonical_u64() {
-          _ => {
-            let __ret: [G; OUT_125] = [__v_17];
-            record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-        }
-      },
-      5u64 => {
-        match __v_1.as_canonical_u64() {
-          _ => {
-            let __ret: [G; OUT_125] = [__v_9];
-            record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-        }
-      },
-      7u64 => {
-        match __v_1.as_canonical_u64() {
-          _ => {
-            let __ret: [G; OUT_125] = [__v_9];
-            record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-        }
-      },
-      0u64 => {
-        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 = G::from_u64(0);
-        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 = { let __values: [G; 32] = [__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]; 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_125] = [__v_77];
-        record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      1u64 => {
-        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 = G::from_u64(0);
-        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 = { let __values: [G; 32] = [__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]; 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_125] = [__v_77];
-        record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      2u64 => {
-        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 = G::from_u64(0);
-        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 = { let __values: [G; 32] = [__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]; 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_125] = [__v_77];
-        record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      3u64 => {
-        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 = G::from_u64(0);
-        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 = { let __values: [G; 32] = [__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]; 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_125] = [__v_77];
-        record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      8u64 => {
-        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 = G::from_u64(0);
-        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 = { let __values: [G; 32] = [__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]; 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_125] = [__v_77];
-        record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_126: usize = 45;
-const IN_126: usize = 45;
-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 __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];
-    match __v_0.as_canonical_u64() {
-      1u64 => {
-        match __v_1.as_canonical_u64() {
-          _ => {
-            let __r_arr: [G; OUT_793] = { let __args: [G; IN_793] = [__v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[793].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_793] = unsafe { *(result.output.as_ptr() as *const [G; OUT_793]) }; __ret } else { aiur_fn_793(__args, record, io_buffer, __cu)? } };
-            let __v_45: G = __r_arr[0];
-            let __v_46: G = G::from_u64(1);
-            let __v_47: G = (__v_45 + __v_46);
-            let __ret: [G; OUT_126] = [__v_47];
-            record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-        }
-      },
-      2u64 => {
-        let __v_45: G = G::from_u64(1);
-        let __ret: [G; OUT_126] = [__v_45];
-        record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __v_45: G = G::from_u64(1);
-        let __ret: [G; OUT_126] = [__v_45];
-        record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_127: usize = 1;
-const IN_127: usize = 1;
-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 __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; 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: 47 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 47] = __args[..47].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 __v_35: G = __loaded[34];
-    let __v_36: G = __loaded[35];
-    let __v_37: G = __loaded[36];
-    let __v_38: G = __loaded[37];
-    let __v_39: G = __loaded[38];
-    let __v_40: G = __loaded[39];
-    let __v_41: G = __loaded[40];
-    let __v_42: G = __loaded[41];
-    let __v_43: G = __loaded[42];
-    let __v_44: G = __loaded[43];
-    let __v_45: G = __loaded[44];
-    let __v_46: G = __loaded[45];
-    let __v_47: G = __loaded[46];
-    match __v_1.as_canonical_u64() {
-      1u64 => {
-        let __v_48: G = G::from_u64(0);
-        let __ret: [G; OUT_127] = [__v_48];
-        record.function_queries[127].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__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_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { 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_48: G = __r_arr[0];
-        let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { 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_49: G = __r_arr[0];
-        let __v_50: G = (__v_48 + __v_49);
-        let __ret: [G; OUT_127] = [__v_50];
-        record.function_queries[127].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-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];
-    match __v_1.as_canonical_u64() {
-      0u64 => {
-        let __v_2: G = G::from_u64(0);
-        let __ret: [G; OUT_128] = [__v_2];
-        record.function_queries[128].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; 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: 47 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 47] = __args[..47].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];
-        let __v_12: G = __loaded[10];
-        let __v_13: G = __loaded[11];
-        let __v_14: G = __loaded[12];
-        let __v_15: G = __loaded[13];
-        let __v_16: G = __loaded[14];
-        let __v_17: G = __loaded[15];
-        let __v_18: G = __loaded[16];
-        let __v_19: G = __loaded[17];
-        let __v_20: G = __loaded[18];
-        let __v_21: G = __loaded[19];
-        let __v_22: G = __loaded[20];
-        let __v_23: G = __loaded[21];
-        let __v_24: G = __loaded[22];
-        let __v_25: G = __loaded[23];
-        let __v_26: G = __loaded[24];
-        let __v_27: G = __loaded[25];
-        let __v_28: G = __loaded[26];
-        let __v_29: G = __loaded[27];
-        let __v_30: G = __loaded[28];
-        let __v_31: G = __loaded[29];
-        let __v_32: G = __loaded[30];
-        let __v_33: G = __loaded[31];
-        let __v_34: G = __loaded[32];
-        let __v_35: G = __loaded[33];
-        let __v_36: G = __loaded[34];
-        let __v_37: G = __loaded[35];
-        let __v_38: G = __loaded[36];
-        let __v_39: G = __loaded[37];
-        let __v_40: G = __loaded[38];
-        let __v_41: G = __loaded[39];
-        let __v_42: G = __loaded[40];
-        let __v_43: G = __loaded[41];
-        let __v_44: G = __loaded[42];
-        let __v_45: G = __loaded[43];
-        let __v_46: G = __loaded[44];
-        let __v_47: G = __loaded[45];
-        let __v_48: G = __loaded[46];
-        match __v_2.as_canonical_u64() {
-          0u64 => {
-            let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__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_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]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { 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_49: G = __r_arr[0];
-            let __v_50: G = G::from_u64(1);
-            let __v_51: G = (__v_1 - __v_50);
-            let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_48, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[128].get_mut(&__args[..]) { 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_52: G = __r_arr[0];
-            let __v_53: G = (__v_49 + __v_52);
-            let __ret: [G; OUT_128] = [__v_53];
-            record.function_queries[128].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-          },
-        }
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_129: usize = 2;
-const IN_129: usize = 2;
-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 __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; 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: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].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 __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_0, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[781].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_781] = unsafe { *(result.output.as_ptr() as *const [G; OUT_781]) }; __ret } else { aiur_fn_781(__args, record, io_buffer, __cu)? } };
-    let __v_8: G = __r_arr[0];
-    match __v_8.as_canonical_u64() {
-      4294967295u64 => {
-        let __v_9: G = G::from_u64(0);
-        let __ret: [G; OUT_129] = [__v_9];
-        record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        let __v_9: G = G::from_u64(1);
-        let __v_10: G = (__v_8 - __v_9);
-        let __ret: [G; OUT_129] = [__v_10];
-        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 = 6;
-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(1);
-        let __v_6: G = G::from_u64(1);
-        let __ret: [G; OUT_130] = [__v_5, __v_6, __v_6, __v_6, __v_6, __v_6];
-        record.function_queries[130].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_5: G = __loaded[0];
-        let __v_6: G = __loaded[1];
-        let __v_7: G = __loaded[2];
-        match __v_5.as_canonical_u64() {
-          0u64 => {
-            let __v_8: G = G::from_u64(1);
-            let __v_9: G = (__v_6 + __v_8);
-            let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { 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_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 __r_arr: [G; OUT_785] = { let __args: [G; IN_785] = [__v_3, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[785].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_785] = unsafe { *(result.output.as_ptr() as *const [G; OUT_785]) }; __ret } else { aiur_fn_785(__args, record, io_buffer, __cu)? } };
-            let __v_16: G = __r_arr[0];
-            let __v_17: G = __r_arr[1];
-            let __v_18: G = __r_arr[2];
-            let __v_19: G = __r_arr[3];
-            let __v_20: G = __r_arr[4];
-            let __v_21: G = __r_arr[5];
-            let __ret: [G; OUT_130] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
-            record.function_queries[130].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
-          },
-        }
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_131: usize = 7;
-const IN_131: usize = 7;
-const OUT_131: usize = 6;
-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 __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 __ret: [G; OUT_131] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6];
-        record.function_queries[131].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __loaded: [G; 48] = { let __mq = record.memory_queries.get_mut(&48).ok_or(ExecError::InvalidMemorySize(48))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 48 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 48] = __args[..48].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 = __loaded[32];
-        let __v_43: G = __loaded[33];
-        let __v_44: G = __loaded[34];
-        let __v_45: G = __loaded[35];
-        let __v_46: G = __loaded[36];
-        let __v_47: G = __loaded[37];
-        let __v_48: G = __loaded[38];
-        let __v_49: G = __loaded[39];
-        let __v_50: G = __loaded[40];
-        let __v_51: G = __loaded[41];
-        let __v_52: G = __loaded[42];
-        let __v_53: G = __loaded[43];
-        let __v_54: G = __loaded[44];
-        let __v_55: G = __loaded[45];
-        let __v_56: G = __loaded[46];
-        let __v_57: G = __loaded[47];
-        match __v_10.as_canonical_u64() {
-          _ => {
-            let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_56, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { 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_58: G = __r_arr[0];
-            let __v_59: G = __r_arr[1];
-            let __v_60: G = __r_arr[2];
-            let __v_61: G = __r_arr[3];
-            let __v_62: G = __r_arr[4];
-            let __v_63: G = __r_arr[5];
-            let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_9, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[131].get_mut(&__args[..]) { 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_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 __v_68: G = __r_arr[4];
-            let __v_69: G = __r_arr[5];
-            let __ret: [G; OUT_131] = [__v_64, __v_65, __v_66, __v_67, __v_68, __v_69];
-            record.function_queries[131].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-        }
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_132: usize = 7;
-const IN_132: usize = 7;
-const OUT_132: usize = 6;
-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 __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 __ret: [G; OUT_132] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6];
-        record.function_queries[132].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __v_10: G = G::from_u64(0);
-        let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_8, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[774].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } else { aiur_fn_774(__args, record, io_buffer, __cu)? } };
-        let __v_11: G = __r_arr[0];
-        match __v_11.as_canonical_u64() {
-          0u64 => {
-            let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { 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_12: G = __r_arr[0];
-            let __r_arr: [G; OUT_785] = { let __args: [G; IN_785] = [__v_8, __v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[785].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_785] = unsafe { *(result.output.as_ptr() as *const [G; OUT_785]) }; __ret } else { aiur_fn_785(__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 __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_9, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { 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_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 __ret: [G; OUT_132] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24];
-            record.function_queries[132].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { 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_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 __ret: [G; OUT_132] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17];
-            record.function_queries[132].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-        }
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_133: usize = 2;
-const IN_133: usize = 2;
-const OUT_133: usize = 6;
-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 = G::from_u64(1);
-    let __v_3: G = G::from_u64(1);
-    let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_0, __v_1, __v_2, __v_3, __v_3, __v_3, __v_3, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[134].get_mut(&__args[..]) { 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_4: G = __r_arr[0];
-    let __v_5: G = __r_arr[1];
-    let __v_6: G = __r_arr[2];
-    let __v_7: G = __r_arr[3];
-    let __v_8: G = __r_arr[4];
-    let __v_9: G = __r_arr[5];
-    let __ret: [G; OUT_133] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9];
-    record.function_queries[133].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_134: usize = 8;
-const IN_134: usize = 8;
-const OUT_134: usize = 6;
-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];
-    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; 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_8: G = __loaded[0];
-    let __v_9: G = __loaded[1];
-    let __v_10: G = __loaded[2];
-    match __v_8.as_canonical_u64() {
-      1u64 => {
-        let __ret: [G; OUT_134] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7];
-        record.function_queries[134].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_11: G = __loaded[0];
-        let __v_12: G = __loaded[1];
-        let __v_13: G = __loaded[2];
-        match __v_11.as_canonical_u64() {
-          0u64 => {
-            let __r_arr: [G; OUT_785] = { let __args: [G; IN_785] = [__v_9, __v_12, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[785].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_785] = unsafe { *(result.output.as_ptr() as *const [G; OUT_785]) }; __ret } else { aiur_fn_785(__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 __v_17: G = __r_arr[3];
-            let __v_18: G = __r_arr[4];
-            let __v_19: G = __r_arr[5];
-            let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[134].get_mut(&__args[..]) { 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_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 __ret: [G; OUT_134] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25];
-            record.function_queries[134].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64()));
-          },
-        }
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_135: usize = 2;
-const IN_135: usize = 2;
-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 __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; 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: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].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 __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_0, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[781].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_781] = unsafe { *(result.output.as_ptr() as *const [G; OUT_781]) }; __ret } else { aiur_fn_781(__args, record, io_buffer, __cu)? } };
-    let __v_8: G = __r_arr[0];
-    let __ret: [G; OUT_135] = [__v_8];
-    record.function_queries[135].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_136: usize = 2;
-const IN_136: usize = 2;
-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 __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(0);
-        let __ret: [G; OUT_136] = [__v_5];
-        record.function_queries[136].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __v_5: G = (__v_3 - __v_0);
-        match __v_5.as_canonical_u64() {
-          0u64 => {
-            let __v_6: G = G::from_u64(1);
-            let __ret: [G; OUT_136] = [__v_6];
-            record.function_queries[136].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[136].get_mut(&__args[..]) { 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_6: G = __r_arr[0];
-            let __ret: [G; OUT_136] = [__v_6];
-            record.function_queries[136].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-        }
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_137: usize = 48;
-const IN_137: usize = 48;
-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 __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];
-    match __v_0.as_canonical_u64() {
-      _ => {
-        match __v_0.as_canonical_u64() {
-          8u64 => {
-            let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[138].get_mut(&__args[..]) { 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_48: G = __r_arr[0];
-            match __v_48.as_canonical_u64() {
-              0u64 => {
-                let __v_49: G = G::from_u64(0);
-                let __ret: [G; OUT_137] = [__v_49];
-                record.function_queries[137].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              1u64 => {
-                let __v_49: G = { let __values: [G; 48] = [__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_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]; let __mq = record.memory_queries.get_mut(&48).ok_or(ExecError::InvalidMemorySize(48))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_137] = [__v_49];
-                record.function_queries[137].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              _ => {
-                return Err(ExecError::MatchNoCase(__v_48.as_canonical_u64()));
-              },
-            }
-          },
-          _ => {
-            let __v_48: G = G::from_u64(0);
-            let __ret: [G; OUT_137] = [__v_48];
-            record.function_queries[137].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-        }
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_138: usize = 1;
-const IN_138: usize = 1;
-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 __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; 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: 47 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 47] = __args[..47].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 __v_35: G = __loaded[34];
-    let __v_36: G = __loaded[35];
-    let __v_37: G = __loaded[36];
-    let __v_38: G = __loaded[37];
-    let __v_39: G = __loaded[38];
-    let __v_40: G = __loaded[39];
-    let __v_41: G = __loaded[40];
-    let __v_42: G = __loaded[41];
-    let __v_43: G = __loaded[42];
-    let __v_44: G = __loaded[43];
-    let __v_45: G = __loaded[44];
-    let __v_46: G = __loaded[45];
-    let __v_47: G = __loaded[46];
-    match __v_1.as_canonical_u64() {
-      0u64 => {
-        let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_47.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr };
-        let __v_48: G = __loaded[0];
-        let __v_49: G = __loaded[1];
-        let __v_50: G = __loaded[2];
-        let __v_51: G = __loaded[3];
-        let __v_52: G = __loaded[4];
-        let __v_53: G = __loaded[5];
-        let __v_54: G = __loaded[6];
-        let __v_55: G = __loaded[7];
-        let __v_56: G = __loaded[8];
-        let __v_57: G = __loaded[9];
-        let __v_58: G = __loaded[10];
-        let __v_59: G = __loaded[11];
-        let __v_60: G = __loaded[12];
-        let __v_61: G = __loaded[13];
-        let __v_62: G = __loaded[14];
-        let __v_63: G = __loaded[15];
-        let __v_64: G = __loaded[16];
-        let __v_65: G = __loaded[17];
-        let __v_66: G = __loaded[18];
-        let __v_67: G = __loaded[19];
-        let __v_68: G = __loaded[20];
-        let __v_69: G = __loaded[21];
-        let __v_70: G = __loaded[22];
-        let __v_71: G = __loaded[23];
-        let __v_72: G = __loaded[24];
-        let __v_73: G = __loaded[25];
-        let __v_74: G = __loaded[26];
-        let __v_75: G = __loaded[27];
-        let __v_76: G = __loaded[28];
-        let __v_77: G = __loaded[29];
-        let __v_78: G = __loaded[30];
-        let __v_79: G = __loaded[31];
-        let __v_80: G = __loaded[32];
-        let __v_81: G = __loaded[33];
-        let __v_82: G = __loaded[34];
-        let __v_83: G = __loaded[35];
-        let __v_84: G = __loaded[36];
-        let __v_85: G = __loaded[37];
-        let __v_86: G = __loaded[38];
-        let __v_87: G = __loaded[39];
-        let __v_88: G = __loaded[40];
-        let __v_89: G = __loaded[41];
-        let __v_90: G = __loaded[42];
-        let __v_91: G = __loaded[43];
-        let __v_92: G = __loaded[44];
-        let __v_93: G = __loaded[45];
-        let __v_94: G = __loaded[46];
-        match __v_48.as_canonical_u64() {
-          1u64 => {
-            match __v_2.as_canonical_u64() {
-              1u64 => {
-                let __v_95: G = G::from_u64(1);
-                let __ret: [G; OUT_138] = [__v_95];
-                record.function_queries[138].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              _ => {
-                let __v_95: G = G::from_u64(0);
-                let __ret: [G; OUT_138] = [__v_95];
-                record.function_queries[138].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-            }
-          },
-          _ => {
-            let __v_95: G = G::from_u64(0);
-            let __ret: [G; OUT_138] = [__v_95];
-            record.function_queries[138].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-        }
-      },
-      _ => {
-        let __v_48: G = G::from_u64(0);
-        let __ret: [G; OUT_138] = [__v_48];
-        record.function_queries[138].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_139: usize = 3;
-const IN_139: usize = 3;
-const OUT_139: usize = 1;
-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 __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_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(0);
-        let __ret: [G; OUT_139] = [__v_6];
-        record.function_queries[139].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_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_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_4 - __v_0);
-            match __v_9.as_canonical_u64() {
-              0u64 => {
-                let __ret: [G; OUT_139] = [__v_7];
-                record.function_queries[139].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              _ => {
-                let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_0, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[139].get_mut(&__args[..]) { 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_10: G = __r_arr[0];
-                let __ret: [G; OUT_139] = [__v_10];
-                record.function_queries[139].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_140: usize = 3;
-const IN_140: usize = 3;
-const OUT_140: usize = 3;
-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 = G::from_u64(1);
-    let __v_4: G = G::from_u64(1);
-    let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __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_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 __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_0, __v_1, __v_2, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[141].get_mut(&__args[..]) { 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_9: G = __r_arr[0];
-    let __v_10: G = __r_arr[1];
-    let __v_11: G = __r_arr[2];
-    let __ret: [G; OUT_140] = [__v_9, __v_10, __v_11];
-    record.function_queries[140].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_141: usize = 5;
-const IN_141: usize = 5;
-const OUT_141: usize = 3;
-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 __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_5: G = __loaded[0];
-    let __v_6: G = __loaded[1];
-    let __v_7: G = __loaded[2];
-    match __v_5.as_canonical_u64() {
-      1u64 => {
-        let __v_8: G = G::from_u64(1);
-        let __v_9: G = G::from_u64(1);
-        let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __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 = 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 __ret: [G; OUT_141] = [__v_10, __v_13, __v_2];
-        record.function_queries[141].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __loaded: [G; 48] = { let __mq = record.memory_queries.get_mut(&48).ok_or(ExecError::InvalidMemorySize(48))?; 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: 48 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 48] = __args[..48].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];
-        let __v_18: G = __loaded[10];
-        let __v_19: G = __loaded[11];
-        let __v_20: G = __loaded[12];
-        let __v_21: G = __loaded[13];
-        let __v_22: G = __loaded[14];
-        let __v_23: G = __loaded[15];
-        let __v_24: G = __loaded[16];
-        let __v_25: G = __loaded[17];
-        let __v_26: G = __loaded[18];
-        let __v_27: G = __loaded[19];
-        let __v_28: G = __loaded[20];
-        let __v_29: G = __loaded[21];
-        let __v_30: G = __loaded[22];
-        let __v_31: G = __loaded[23];
-        let __v_32: G = __loaded[24];
-        let __v_33: G = __loaded[25];
-        let __v_34: G = __loaded[26];
-        let __v_35: G = __loaded[27];
-        let __v_36: G = __loaded[28];
-        let __v_37: G = __loaded[29];
-        let __v_38: G = __loaded[30];
-        let __v_39: G = __loaded[31];
-        let __v_40: G = __loaded[32];
-        let __v_41: G = __loaded[33];
-        let __v_42: G = __loaded[34];
-        let __v_43: G = __loaded[35];
-        let __v_44: G = __loaded[36];
-        let __v_45: G = __loaded[37];
-        let __v_46: G = __loaded[38];
-        let __v_47: G = __loaded[39];
-        let __v_48: G = __loaded[40];
-        let __v_49: G = __loaded[41];
-        let __v_50: G = __loaded[42];
-        let __v_51: G = __loaded[43];
-        let __v_52: G = __loaded[44];
-        let __v_53: G = __loaded[45];
-        let __v_54: G = __loaded[46];
-        let __v_55: G = __loaded[47];
-        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_56: G = __loaded[0];
-        let __v_57: G = __loaded[1];
-        let __v_58: G = __loaded[2];
-        match __v_56.as_canonical_u64() {
-          0u64 => {
-            match __v_8.as_canonical_u64() {
-              _ => {
-                match __v_8.as_canonical_u64() {
-                  8u64 => {
-                    let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__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, __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]; let __cu = unconstrained; if let Some(result) = record.function_queries[137].get_mut(&__args[..]) { 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_59: G = __r_arr[0];
-                    let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_59.as_canonical_u64() {
-  0u64 => {
-    let __v_60: G = G::from_u64(0);
-    break '__mc_0 [__v_60];
-  },
-  _ => {
-    let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_59, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[136].get_mut(&__args[..]) { 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_60: G = __r_arr[0];
-    break '__mc_0 [__v_60];
-  },
-}
- };
-                    let __v_60: G = __mc_out___mc_0[0];
-                    match __v_60.as_canonical_u64() {
-                      1u64 => {
-                        let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_59, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[139].get_mut(&__args[..]) { 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_61: G = __r_arr[0];
-                        let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_7, __v_58, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[141].get_mut(&__args[..]) { 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_62: G = __r_arr[0];
-                        let __v_63: G = __r_arr[1];
-                        let __v_64: G = __r_arr[2];
-                        let __v_65: G = G::from_u64(0);
-                        let __v_66: G = { let __values: [G; 3] = [__v_65, __v_57, __v_62]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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 = G::from_u64(0);
-                        let __v_68: G = { let __values: [G; 3] = [__v_67, __v_61, __v_63]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_141] = [__v_66, __v_68, __v_64];
-                        record.function_queries[141].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                        return Ok(__ret);
-                      },
-                      0u64 => {
-                        let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { 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_61: G = __r_arr[0];
-                        let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_59.as_canonical_u64() {
-  0u64 => {
-    break '__mc_1 [__v_3];
-  },
-  _ => {
-    let __v_62: G = G::from_u64(0);
-    let __v_63: G = { let __values: [G; 3] = [__v_62, __v_59, __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 } };
-    break '__mc_1 [__v_63];
-  },
-}
- };
-                        let __v_62: G = __mc_out___mc_1[0];
-                        let __mc_out___mc_2: [G; 1] = '__mc_2: { match __v_59.as_canonical_u64() {
-  0u64 => {
-    break '__mc_2 [__v_4];
-  },
-  _ => {
-    let __v_63: G = G::from_u64(0);
-    let __v_64: G = { let __values: [G; 3] = [__v_63, __v_2, __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 } };
-    break '__mc_2 [__v_64];
-  },
-}
- };
-                        let __v_63: G = __mc_out___mc_2[0];
-                        let __v_64: G = (__v_2 + __v_61);
-                        let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_7, __v_58, __v_64, __v_62, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[141].get_mut(&__args[..]) { 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_65: G = __r_arr[0];
-                        let __v_66: G = __r_arr[1];
-                        let __v_67: G = __r_arr[2];
-                        let __v_68: G = G::from_u64(0);
-                        let __v_69: G = { let __values: [G; 3] = [__v_68, __v_57, __v_65]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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 = G::from_u64(0);
-                        let __v_71: G = { let __values: [G; 3] = [__v_70, __v_2, __v_66]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_141] = [__v_69, __v_71, __v_67];
-                        record.function_queries[141].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                        return Ok(__ret);
-                      },
-                      _ => {
-                        return Err(ExecError::MatchNoCase(__v_60.as_canonical_u64()));
-                      },
-                    }
-                  },
-                  6u64 => {
-                    let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_7, __v_58, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[141].get_mut(&__args[..]) { 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_59: G = __r_arr[0];
-                    let __v_60: G = __r_arr[1];
-                    let __v_61: G = __r_arr[2];
-                    let __ret: [G; OUT_141] = [__v_59, __v_60, __v_61];
-                    record.function_queries[141].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
-                  4u64 => {
-                    let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_7, __v_58, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[141].get_mut(&__args[..]) { 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_59: G = __r_arr[0];
-                    let __v_60: G = __r_arr[1];
-                    let __v_61: G = __r_arr[2];
-                    let __ret: [G; OUT_141] = [__v_59, __v_60, __v_61];
-                    record.function_queries[141].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
-                  5u64 => {
-                    let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_7, __v_58, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[141].get_mut(&__args[..]) { 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_59: G = __r_arr[0];
-                    let __v_60: G = __r_arr[1];
-                    let __v_61: G = __r_arr[2];
-                    let __ret: [G; OUT_141] = [__v_59, __v_60, __v_61];
-                    record.function_queries[141].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
-                  7u64 => {
-                    let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_7, __v_58, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[141].get_mut(&__args[..]) { 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_59: G = __r_arr[0];
-                    let __v_60: G = __r_arr[1];
-                    let __v_61: G = __r_arr[2];
-                    let __ret: [G; OUT_141] = [__v_59, __v_60, __v_61];
-                    record.function_queries[141].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
-                  0u64 => {
-                    let __v_59: G = G::from_u64(1);
-                    let __v_60: G = (__v_2 + __v_59);
-                    let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_7, __v_58, __v_60, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[141].get_mut(&__args[..]) { 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_61: G = __r_arr[0];
-                    let __v_62: G = __r_arr[1];
-                    let __v_63: G = __r_arr[2];
-                    let __ret: [G; OUT_141] = [__v_61, __v_62, __v_63];
-                    record.function_queries[141].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
-                  2u64 => {
-                    let __v_59: G = G::from_u64(1);
-                    let __v_60: G = (__v_2 + __v_59);
-                    let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_7, __v_58, __v_60, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[141].get_mut(&__args[..]) { 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_61: G = __r_arr[0];
-                    let __v_62: G = __r_arr[1];
-                    let __v_63: G = __r_arr[2];
-                    let __ret: [G; OUT_141] = [__v_61, __v_62, __v_63];
-                    record.function_queries[141].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
-                  3u64 => {
-                    let __v_59: G = G::from_u64(1);
-                    let __v_60: G = (__v_2 + __v_59);
-                    let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_7, __v_58, __v_60, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[141].get_mut(&__args[..]) { 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_61: G = __r_arr[0];
-                    let __v_62: G = __r_arr[1];
-                    let __v_63: G = __r_arr[2];
-                    let __ret: [G; OUT_141] = [__v_61, __v_62, __v_63];
-                    record.function_queries[141].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
-                  1u64 => {
-                    let __v_59: G = G::from_u64(1);
-                    let __v_60: G = (__v_2 + __v_59);
-                    let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_7, __v_58, __v_60, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[141].get_mut(&__args[..]) { 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_61: G = __r_arr[0];
-                    let __v_62: G = __r_arr[1];
-                    let __v_63: G = __r_arr[2];
-                    let __ret: [G; OUT_141] = [__v_61, __v_62, __v_63];
-                    record.function_queries[141].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
-                  _ => {
-                    return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64()));
-                  },
-                }
-              },
-            }
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_56.as_canonical_u64()));
-          },
-        }
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_142: usize = 4;
-const IN_142: usize = 4;
-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 = 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 __v_7: G = G::from_u64(1);
-    let __v_8: G = G::from_u64(1);
-    let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __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 __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_0, __v_1, __v_2, __v_3, __v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[143].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_143] = unsafe { *(result.output.as_ptr() as *const [G; OUT_143]) }; __ret } else { aiur_fn_143(__args, record, io_buffer, __cu)? } };
-    let __v_10: G = __r_arr[0];
-    let __ret: [G; OUT_142] = [__v_10];
-    record.function_queries[142].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_143: usize = 6;
-const IN_143: usize = 6;
-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 __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_6: G = __loaded[0];
-    let __v_7: G = __loaded[1];
-    let __v_8: G = __loaded[2];
-    match __v_6.as_canonical_u64() {
-      1u64 => {
-        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 __ret: [G; OUT_143] = [__v_11];
-        record.function_queries[143].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __loaded: [G; 48] = { let __mq = record.memory_queries.get_mut(&48).ok_or(ExecError::InvalidMemorySize(48))?; 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: 48 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 48] = __args[..48].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 __v_17: G = __loaded[8];
-        let __v_18: G = __loaded[9];
-        let __v_19: G = __loaded[10];
-        let __v_20: G = __loaded[11];
-        let __v_21: G = __loaded[12];
-        let __v_22: G = __loaded[13];
-        let __v_23: G = __loaded[14];
-        let __v_24: G = __loaded[15];
-        let __v_25: G = __loaded[16];
-        let __v_26: G = __loaded[17];
-        let __v_27: G = __loaded[18];
-        let __v_28: G = __loaded[19];
-        let __v_29: G = __loaded[20];
-        let __v_30: G = __loaded[21];
-        let __v_31: G = __loaded[22];
-        let __v_32: G = __loaded[23];
-        let __v_33: G = __loaded[24];
-        let __v_34: G = __loaded[25];
-        let __v_35: G = __loaded[26];
-        let __v_36: G = __loaded[27];
-        let __v_37: G = __loaded[28];
-        let __v_38: G = __loaded[29];
-        let __v_39: G = __loaded[30];
-        let __v_40: G = __loaded[31];
-        let __v_41: G = __loaded[32];
-        let __v_42: G = __loaded[33];
-        let __v_43: G = __loaded[34];
-        let __v_44: G = __loaded[35];
-        let __v_45: G = __loaded[36];
-        let __v_46: G = __loaded[37];
-        let __v_47: G = __loaded[38];
-        let __v_48: G = __loaded[39];
-        let __v_49: G = __loaded[40];
-        let __v_50: G = __loaded[41];
-        let __v_51: G = __loaded[42];
-        let __v_52: G = __loaded[43];
-        let __v_53: G = __loaded[44];
-        let __v_54: G = __loaded[45];
-        let __v_55: G = __loaded[46];
-        let __v_56: G = __loaded[47];
-        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_57: G = __loaded[0];
-        let __v_58: G = __loaded[1];
-        let __v_59: G = __loaded[2];
-        match __v_57.as_canonical_u64() {
-          0u64 => {
-            match __v_9.as_canonical_u64() {
-              _ => {
-                match __v_9.as_canonical_u64() {
-                  8u64 => {
-                    let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__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]; let __cu = unconstrained; if let Some(result) = record.function_queries[137].get_mut(&__args[..]) { 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_60: G = __r_arr[0];
-                    let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_60.as_canonical_u64() {
-  0u64 => {
-    let __v_61: G = G::from_u64(0);
-    break '__mc_0 [__v_61];
-  },
-  _ => {
-    let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_60, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[136].get_mut(&__args[..]) { 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_61: G = __r_arr[0];
-    break '__mc_0 [__v_61];
-  },
-}
- };
-                    let __v_61: G = __mc_out___mc_0[0];
-                    match __v_61.as_canonical_u64() {
-                      1u64 => {
-                        let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_60, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[139].get_mut(&__args[..]) { 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_62: G = __r_arr[0];
-                        let __v_63: G = G::from_u64(0);
-                        let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_8, __v_59, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[143].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_143] = unsafe { *(result.output.as_ptr() as *const [G; OUT_143]) }; __ret } else { aiur_fn_143(__args, record, io_buffer, __cu)? } };
-                        let __v_64: G = __r_arr[0];
-                        let __v_65: G = { let __values: [G; 3] = [__v_63, __v_62, __v_64]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_143] = [__v_65];
-                        record.function_queries[143].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                        return Ok(__ret);
-                      },
-                      0u64 => {
-                        let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { 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_62: G = __r_arr[0];
-                        let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_60.as_canonical_u64() {
-  0u64 => {
-    break '__mc_1 [__v_4];
-  },
-  _ => {
-    let __v_63: G = G::from_u64(0);
-    let __v_64: G = { let __values: [G; 3] = [__v_63, __v_60, __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 } };
-    break '__mc_1 [__v_64];
-  },
-}
- };
-                        let __v_63: G = __mc_out___mc_1[0];
-                        let __mc_out___mc_2: [G; 1] = '__mc_2: { match __v_60.as_canonical_u64() {
-  0u64 => {
-    break '__mc_2 [__v_5];
-  },
-  _ => {
-    let __v_64: G = G::from_u64(0);
-    let __v_65: G = { let __values: [G; 3] = [__v_64, __v_3, __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 } };
-    break '__mc_2 [__v_65];
-  },
-}
- };
-                        let __v_64: G = __mc_out___mc_2[0];
-                        let __v_65: G = G::from_u64(0);
-                        let __v_66: G = (__v_3 + __v_62);
-                        let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_8, __v_59, __v_2, __v_66, __v_63, __v_64]; let __cu = unconstrained; if let Some(result) = record.function_queries[143].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_143] = unsafe { *(result.output.as_ptr() as *const [G; OUT_143]) }; __ret } else { aiur_fn_143(__args, record, io_buffer, __cu)? } };
-                        let __v_67: G = __r_arr[0];
-                        let __v_68: G = { let __values: [G; 3] = [__v_65, __v_3, __v_67]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_143] = [__v_68];
-                        record.function_queries[143].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                        return Ok(__ret);
-                      },
-                      _ => {
-                        return Err(ExecError::MatchNoCase(__v_61.as_canonical_u64()));
-                      },
-                    }
-                  },
-                  6u64 => {
-                    match __v_10.as_canonical_u64() {
-                      _ => {
-                        let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_18, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[135].get_mut(&__args[..]) { 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_60: G = __r_arr[0];
-                        let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { 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_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 __v_72: G = __r_arr[11];
-                        let __v_73: G = __r_arr[12];
-                        let __v_74: G = __r_arr[13];
-                        let __v_75: G = __r_arr[14];
-                        let __v_76: G = __r_arr[15];
-                        let __v_77: G = __r_arr[16];
-                        let __v_78: G = __r_arr[17];
-                        let __v_79: G = __r_arr[18];
-                        let __v_80: G = __r_arr[19];
-                        let __v_81: G = __r_arr[20];
-                        let __v_82: G = __r_arr[21];
-                        let __v_83: G = __r_arr[22];
-                        let __v_84: G = __r_arr[23];
-                        let __v_85: G = __r_arr[24];
-                        let __v_86: G = __r_arr[25];
-                        let __v_87: G = __r_arr[26];
-                        let __v_88: G = __r_arr[27];
-                        let __v_89: G = __r_arr[28];
-                        let __v_90: G = __r_arr[29];
-                        let __v_91: G = __r_arr[30];
-                        let __v_92: G = __r_arr[31];
-                        let __v_93: G = __r_arr[32];
-                        let __v_94: G = __r_arr[33];
-                        let __v_95: G = __r_arr[34];
-                        let __v_96: G = __r_arr[35];
-                        let __v_97: G = __r_arr[36];
-                        let __v_98: G = __r_arr[37];
-                        let __v_99: G = __r_arr[38];
-                        let __v_100: G = __r_arr[39];
-                        let __v_101: G = __r_arr[40];
-                        let __v_102: G = __r_arr[41];
-                        let __v_103: G = __r_arr[42];
-                        let __v_104: G = __r_arr[43];
-                        let __v_105: G = __r_arr[44];
-                        let __v_106: G = __r_arr[45];
-                        let __v_107: G = __r_arr[46];
-                        let __v_108: G = __r_arr[47];
-                        match __v_61.as_canonical_u64() {
-                          _ => {
-                            match __v_61.as_canonical_u64() {
-                              8u64 => {
-                                let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } };
-                                let __v_109: G = __r_arr[0];
-                                let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_62, __v_109]; let __cu = unconstrained; if let Some(result) = record.function_queries[128].get_mut(&__args[..]) { 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_110: G = __r_arr[0];
-                                let __v_111: G = G::from_u64(0);
-                                let __v_112: G = (__v_60 + __v_110);
-                                let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_8, __v_59, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[143].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_143] = unsafe { *(result.output.as_ptr() as *const [G; OUT_143]) }; __ret } else { aiur_fn_143(__args, record, io_buffer, __cu)? } };
-                                let __v_113: G = __r_arr[0];
-                                let __v_114: G = { let __values: [G; 3] = [__v_111, __v_112, __v_113]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_143] = [__v_114];
-                                record.function_queries[143].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                return Ok(__ret);
-                              },
-                              _ => {
-                                return Err(ExecError::MatchNoCase(__v_61.as_canonical_u64()));
-                              },
-                            }
-                          },
-                        }
-                      },
-                    }
-                  },
-                  4u64 => {
-                    match __v_10.as_canonical_u64() {
-                      _ => {
-                        let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_26, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[135].get_mut(&__args[..]) { 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_60: G = __r_arr[0];
-                        let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { 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_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 __v_72: G = __r_arr[11];
-                        let __v_73: G = __r_arr[12];
-                        let __v_74: G = __r_arr[13];
-                        let __v_75: G = __r_arr[14];
-                        let __v_76: G = __r_arr[15];
-                        let __v_77: G = __r_arr[16];
-                        let __v_78: G = __r_arr[17];
-                        let __v_79: G = __r_arr[18];
-                        let __v_80: G = __r_arr[19];
-                        let __v_81: G = __r_arr[20];
-                        let __v_82: G = __r_arr[21];
-                        let __v_83: G = __r_arr[22];
-                        let __v_84: G = __r_arr[23];
-                        let __v_85: G = __r_arr[24];
-                        let __v_86: G = __r_arr[25];
-                        let __v_87: G = __r_arr[26];
-                        let __v_88: G = __r_arr[27];
-                        let __v_89: G = __r_arr[28];
-                        let __v_90: G = __r_arr[29];
-                        let __v_91: G = __r_arr[30];
-                        let __v_92: G = __r_arr[31];
-                        let __v_93: G = __r_arr[32];
-                        let __v_94: G = __r_arr[33];
-                        let __v_95: G = __r_arr[34];
-                        let __v_96: G = __r_arr[35];
-                        let __v_97: G = __r_arr[36];
-                        let __v_98: G = __r_arr[37];
-                        let __v_99: G = __r_arr[38];
-                        let __v_100: G = __r_arr[39];
-                        let __v_101: G = __r_arr[40];
-                        let __v_102: G = __r_arr[41];
-                        let __v_103: G = __r_arr[42];
-                        let __v_104: G = __r_arr[43];
-                        let __v_105: G = __r_arr[44];
-                        let __v_106: G = __r_arr[45];
-                        let __v_107: G = __r_arr[46];
-                        let __v_108: G = __r_arr[47];
-                        match __v_61.as_canonical_u64() {
-                          _ => {
-                            match __v_61.as_canonical_u64() {
-                              8u64 => {
-                                let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } };
-                                let __v_109: G = __r_arr[0];
-                                let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_62, __v_109]; let __cu = unconstrained; if let Some(result) = record.function_queries[128].get_mut(&__args[..]) { 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_110: G = __r_arr[0];
-                                let __v_111: G = G::from_u64(0);
-                                let __v_112: G = G::from_u64(1);
-                                let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } };
-                                let __v_113: G = __r_arr[0];
-                                let __v_114: G = (__v_112 + __v_113);
-                                let __v_115: G = (__v_110 + __v_114);
-                                let __v_116: G = (__v_60 + __v_115);
-                                let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_8, __v_59, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[143].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_143] = unsafe { *(result.output.as_ptr() as *const [G; OUT_143]) }; __ret } else { aiur_fn_143(__args, record, io_buffer, __cu)? } };
-                                let __v_117: G = __r_arr[0];
-                                let __v_118: G = { let __values: [G; 3] = [__v_111, __v_116, __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 __ret: [G; OUT_143] = [__v_118];
-                                record.function_queries[143].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                return Ok(__ret);
-                              },
-                              _ => {
-                                return Err(ExecError::MatchNoCase(__v_61.as_canonical_u64()));
-                              },
-                            }
-                          },
-                        }
-                      },
-                    }
-                  },
-                  5u64 => {
-                    match __v_10.as_canonical_u64() {
-                      _ => {
-                        let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_18, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[135].get_mut(&__args[..]) { 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_60: G = __r_arr[0];
-                        let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { 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_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 __v_72: G = __r_arr[11];
-                        let __v_73: G = __r_arr[12];
-                        let __v_74: G = __r_arr[13];
-                        let __v_75: G = __r_arr[14];
-                        let __v_76: G = __r_arr[15];
-                        let __v_77: G = __r_arr[16];
-                        let __v_78: G = __r_arr[17];
-                        let __v_79: G = __r_arr[18];
-                        let __v_80: G = __r_arr[19];
-                        let __v_81: G = __r_arr[20];
-                        let __v_82: G = __r_arr[21];
-                        let __v_83: G = __r_arr[22];
-                        let __v_84: G = __r_arr[23];
-                        let __v_85: G = __r_arr[24];
-                        let __v_86: G = __r_arr[25];
-                        let __v_87: G = __r_arr[26];
-                        let __v_88: G = __r_arr[27];
-                        let __v_89: G = __r_arr[28];
-                        let __v_90: G = __r_arr[29];
-                        let __v_91: G = __r_arr[30];
-                        let __v_92: G = __r_arr[31];
-                        let __v_93: G = __r_arr[32];
-                        let __v_94: G = __r_arr[33];
-                        let __v_95: G = __r_arr[34];
-                        let __v_96: G = __r_arr[35];
-                        let __v_97: G = __r_arr[36];
-                        let __v_98: G = __r_arr[37];
-                        let __v_99: G = __r_arr[38];
-                        let __v_100: G = __r_arr[39];
-                        let __v_101: G = __r_arr[40];
-                        let __v_102: G = __r_arr[41];
-                        let __v_103: G = __r_arr[42];
-                        let __v_104: G = __r_arr[43];
-                        let __v_105: G = __r_arr[44];
-                        let __v_106: G = __r_arr[45];
-                        let __v_107: G = __r_arr[46];
-                        let __v_108: G = __r_arr[47];
-                        match __v_61.as_canonical_u64() {
-                          _ => {
-                            match __v_61.as_canonical_u64() {
-                              8u64 => {
-                                let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } };
-                                let __v_109: G = __r_arr[0];
-                                let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_62, __v_109]; let __cu = unconstrained; if let Some(result) = record.function_queries[128].get_mut(&__args[..]) { 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_110: G = __r_arr[0];
-                                let __v_111: G = G::from_u64(0);
-                                let __v_112: G = (__v_60 + __v_110);
-                                let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_8, __v_59, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[143].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_143] = unsafe { *(result.output.as_ptr() as *const [G; OUT_143]) }; __ret } else { aiur_fn_143(__args, record, io_buffer, __cu)? } };
-                                let __v_113: G = __r_arr[0];
-                                let __v_114: G = { let __values: [G; 3] = [__v_111, __v_112, __v_113]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_143] = [__v_114];
-                                record.function_queries[143].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                return Ok(__ret);
-                              },
-                              _ => {
-                                return Err(ExecError::MatchNoCase(__v_61.as_canonical_u64()));
-                              },
-                            }
-                          },
-                        }
-                      },
-                    }
-                  },
-                  7u64 => {
-                    match __v_10.as_canonical_u64() {
-                      _ => {
-                        let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_18, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[135].get_mut(&__args[..]) { 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_60: G = __r_arr[0];
-                        let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { 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_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 __v_72: G = __r_arr[11];
-                        let __v_73: G = __r_arr[12];
-                        let __v_74: G = __r_arr[13];
-                        let __v_75: G = __r_arr[14];
-                        let __v_76: G = __r_arr[15];
-                        let __v_77: G = __r_arr[16];
-                        let __v_78: G = __r_arr[17];
-                        let __v_79: G = __r_arr[18];
-                        let __v_80: G = __r_arr[19];
-                        let __v_81: G = __r_arr[20];
-                        let __v_82: G = __r_arr[21];
-                        let __v_83: G = __r_arr[22];
-                        let __v_84: G = __r_arr[23];
-                        let __v_85: G = __r_arr[24];
-                        let __v_86: G = __r_arr[25];
-                        let __v_87: G = __r_arr[26];
-                        let __v_88: G = __r_arr[27];
-                        let __v_89: G = __r_arr[28];
-                        let __v_90: G = __r_arr[29];
-                        let __v_91: G = __r_arr[30];
-                        let __v_92: G = __r_arr[31];
-                        let __v_93: G = __r_arr[32];
-                        let __v_94: G = __r_arr[33];
-                        let __v_95: G = __r_arr[34];
-                        let __v_96: G = __r_arr[35];
-                        let __v_97: G = __r_arr[36];
-                        let __v_98: G = __r_arr[37];
-                        let __v_99: G = __r_arr[38];
-                        let __v_100: G = __r_arr[39];
-                        let __v_101: G = __r_arr[40];
-                        let __v_102: G = __r_arr[41];
-                        let __v_103: G = __r_arr[42];
-                        let __v_104: G = __r_arr[43];
-                        let __v_105: G = __r_arr[44];
-                        let __v_106: G = __r_arr[45];
-                        let __v_107: G = __r_arr[46];
-                        let __v_108: G = __r_arr[47];
-                        match __v_61.as_canonical_u64() {
-                          _ => {
-                            match __v_61.as_canonical_u64() {
-                              8u64 => {
-                                let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } };
-                                let __v_109: G = __r_arr[0];
-                                let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_62, __v_109]; let __cu = unconstrained; if let Some(result) = record.function_queries[128].get_mut(&__args[..]) { 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_110: G = __r_arr[0];
-                                let __v_111: G = G::from_u64(0);
-                                let __v_112: G = (__v_60 + __v_110);
-                                let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_8, __v_59, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[143].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_143] = unsafe { *(result.output.as_ptr() as *const [G; OUT_143]) }; __ret } else { aiur_fn_143(__args, record, io_buffer, __cu)? } };
-                                let __v_113: G = __r_arr[0];
-                                let __v_114: G = { let __values: [G; 3] = [__v_111, __v_112, __v_113]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_143] = [__v_114];
-                                record.function_queries[143].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                return Ok(__ret);
-                              },
-                              _ => {
-                                return Err(ExecError::MatchNoCase(__v_61.as_canonical_u64()));
-                              },
-                            }
-                          },
-                        }
-                      },
-                    }
-                  },
-                  _ => {
-                    let __v_60: G = G::from_u64(0);
-                    let __v_61: G = G::from_u64(1);
-                    let __v_62: G = (__v_3 + __v_61);
-                    let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_8, __v_59, __v_2, __v_62, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[143].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_143] = unsafe { *(result.output.as_ptr() as *const [G; OUT_143]) }; __ret } else { aiur_fn_143(__args, record, io_buffer, __cu)? } };
-                    let __v_63: G = __r_arr[0];
-                    let __v_64: G = { let __values: [G; 3] = [__v_60, __v_3, __v_63]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_143] = [__v_64];
-                    record.function_queries[143].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
-                }
-              },
-            }
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_57.as_canonical_u64()));
-          },
-        }
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_144: usize = 2;
-const IN_144: usize = 2;
-const OUT_144: usize = 2;
-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 __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(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 __v_8: G = G::from_u64(1);
-        let __v_9: G = G::from_u64(1);
-        let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __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 __ret: [G; OUT_144] = [__v_7, __v_10];
-        record.function_queries[144].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[144].get_mut(&__args[..]) { 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_5: G = __r_arr[0];
-        let __v_6: G = __r_arr[1];
-        let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; 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: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].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 __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_3, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[781].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_781] = unsafe { *(result.output.as_ptr() as *const [G; OUT_781]) }; __ret } else { aiur_fn_781(__args, record, io_buffer, __cu)? } };
-        let __v_13: G = __r_arr[0];
-        match __v_13.as_canonical_u64() {
-          4294967295u64 => {
-            let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { 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 __v_15: G = G::from_u64(0);
-            let __v_16: G = G::from_u64(0);
-            let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __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 __v_18: G = G::from_u64(0);
-            let __v_19: G = { let __values: [G; 3] = [__v_18, __v_14, __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_144] = [__v_17, __v_19];
-            record.function_queries[144].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            let __v_14: G = G::from_u64(0);
-            let __v_15: G = G::from_u64(1);
-            let __v_16: G = (__v_13 - __v_15);
-            let __v_17: G = { let __values: [G; 3] = [__v_14, __v_16, __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 __v_18: G = G::from_u64(0);
-            let __v_19: G = G::from_u64(1);
-            let __v_20: G = G::from_u64(1);
-            let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __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_18, __v_21, __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_144] = [__v_17, __v_22];
-            record.function_queries[144].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-        }
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-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; 48] = { let __mq = record.memory_queries.get_mut(&48).ok_or(ExecError::InvalidMemorySize(48))?; 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: 48 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 48] = __args[..48].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 __v_35: G = __loaded[34];
-    let __v_36: G = __loaded[35];
-    let __v_37: G = __loaded[36];
-    let __v_38: G = __loaded[37];
-    let __v_39: G = __loaded[38];
-    let __v_40: G = __loaded[39];
-    let __v_41: G = __loaded[40];
-    let __v_42: G = __loaded[41];
-    let __v_43: G = __loaded[42];
-    let __v_44: G = __loaded[43];
-    let __v_45: G = __loaded[44];
-    let __v_46: G = __loaded[45];
-    let __v_47: G = __loaded[46];
-    let __v_48: G = __loaded[47];
-    match __v_1.as_canonical_u64() {
-      _ => {
-        match __v_1.as_canonical_u64() {
-          8u64 => {
-            let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[138].get_mut(&__args[..]) { 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_49: G = __r_arr[0];
-            match __v_49.as_canonical_u64() {
-              0u64 => {
-                let __v_50: G = G::from_u64(0);
-                let __ret: [G; OUT_145] = [__v_50];
-                record.function_queries[145].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              1u64 => {
-                let __ret: [G; OUT_145] = [__v_0];
-                record.function_queries[145].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              _ => {
-                return Err(ExecError::MatchNoCase(__v_49.as_canonical_u64()));
-              },
-            }
-          },
-          _ => {
-            let __v_49: G = G::from_u64(0);
-            let __ret: [G; OUT_145] = [__v_49];
-            record.function_queries[145].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-        }
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_146: usize = 4;
-const IN_146: usize = 4;
-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 __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 __ret: [G; OUT_146] = [__v_3];
-        record.function_queries[146].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_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_7: G = __loaded[0];
-        let __v_8: G = __loaded[1];
-        let __v_9: G = __loaded[2];
-        match __v_7.as_canonical_u64() {
-          0u64 => {
-            let __v_10: G = (__v_5 - __v_0);
-            match __v_10.as_canonical_u64() {
-              0u64 => {
-                let __ret: [G; OUT_146] = [__v_8];
-                record.function_queries[146].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              _ => {
-                let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_0, __v_6, __v_9, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { 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_11: G = __r_arr[0];
-                let __ret: [G; OUT_146] = [__v_11];
-                record.function_queries[146].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_147: usize = 4;
-const IN_147: usize = 4;
-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];
-    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_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_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; 3] = [__v_7, __v_8, __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_147] = [__v_9];
-        record.function_queries[147].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_7: G = __loaded[0];
-        let __v_8: G = __loaded[1];
-        let __v_9: G = __loaded[2];
-        match __v_7.as_canonical_u64() {
-          0u64 => {
-            let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[145].get_mut(&__args[..]) { 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_10: G = __r_arr[0];
-            let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_10.as_canonical_u64() {
-  0u64 => {
-    break '__mc_0 [__v_8];
-  },
-  _ => {
-    let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_10, __v_2, __v_3, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { 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_11: G = __r_arr[0];
-    break '__mc_0 [__v_11];
-  },
-}
- };
-            let __v_11: G = __mc_out___mc_0[0];
-            let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_10.as_canonical_u64() {
-  0u64 => {
-    break '__mc_1 [__v_2];
-  },
-  _ => {
-    let __v_12: G = G::from_u64(0);
-    let __v_13: G = { let __values: [G; 3] = [__v_12, __v_10, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    break '__mc_1 [__v_13];
-  },
-}
- };
-            let __v_12: G = __mc_out___mc_1[0];
-            let __mc_out___mc_2: [G; 1] = '__mc_2: { match __v_10.as_canonical_u64() {
-  0u64 => {
-    break '__mc_2 [__v_3];
-  },
-  _ => {
-    let __v_13: G = G::from_u64(0);
-    let __v_14: G = { let __values: [G; 3] = [__v_13, __v_11, __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 } };
-    break '__mc_2 [__v_14];
-  },
-}
- };
-            let __v_13: G = __mc_out___mc_2[0];
-            let __v_14: G = G::from_u64(0);
-            let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_6, __v_9, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } else { aiur_fn_147(__args, record, io_buffer, __cu)? } };
-            let __v_15: G = __r_arr[0];
-            let __v_16: G = { let __values: [G; 3] = [__v_14, __v_11, __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 __ret: [G; OUT_147] = [__v_16];
-            record.function_queries[147].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_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 __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 __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 __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_0, __v_1, __v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } else { aiur_fn_147(__args, record, io_buffer, __cu)? } };
-    let __v_8: G = __r_arr[0];
-    let __ret: [G; OUT_148] = [__v_8];
-    record.function_queries[148].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_149: usize = 10;
-const IN_149: usize = 10;
-const OUT_149: usize = 6;
-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];
-    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_10: G = __loaded[0];
-    let __v_11: G = __loaded[1];
-    let __v_12: G = __loaded[2];
-    match __v_10.as_canonical_u64() {
-      1u64 => {
-        let __ret: [G; OUT_149] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9];
-        record.function_queries[149].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_13: G = __loaded[0];
-        let __v_14: G = __loaded[1];
-        let __v_15: G = __loaded[2];
-        match __v_13.as_canonical_u64() {
-          0u64 => {
-            let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[145].get_mut(&__args[..]) { 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_16: G = __r_arr[0];
-            match __v_16.as_canonical_u64() {
-              0u64 => {
-                let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_12, __v_15, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { 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_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 __ret: [G; OUT_149] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22];
-                record.function_queries[149].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              _ => {
-                let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_16, __v_2, __v_3, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { 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_17: G = __r_arr[0];
-                let __v_18: G = G::from_u64(0);
-                let __v_19: G = { let __values: [G; 3] = [__v_18, __v_16, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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 = G::from_u64(0);
-                let __v_21: G = { let __values: [G; 3] = [__v_20, __v_17, __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_785] = { let __args: [G; IN_785] = [__v_11, __v_17, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[785].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_785] = unsafe { *(result.output.as_ptr() as *const [G; OUT_785]) }; __ret } else { aiur_fn_785(__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 __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_12, __v_15, __v_19, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { 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_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 __ret: [G; OUT_149] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33];
-                record.function_queries[149].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-            }
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64()));
-          },
-        }
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_150: usize = 2;
-const IN_150: usize = 2;
-const OUT_150: usize = 6;
-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 = 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 __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 __v_8: G = G::from_u64(1);
-    let __v_9: G = G::from_u64(1);
-    let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_0, __v_1, __v_4, __v_7, __v_8, __v_9, __v_9, __v_9, __v_9, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { 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_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 __ret: [G; OUT_150] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15];
-    record.function_queries[150].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 = 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 __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; 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: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].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];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
-        let __ret: [G; OUT_151] = [__v_0];
-        record.function_queries[151].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; 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: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].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 __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_0, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[774].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } else { aiur_fn_774(__args, record, io_buffer, __cu)? } };
-        let __v_14: G = __r_arr[0];
-        let __ret: [G; OUT_151] = [__v_14];
-        record.function_queries[151].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_152: usize = 3;
-const IN_152: usize = 3;
-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 __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[153].get_mut(&__args[..]) { 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_3: G = __r_arr[0];
-    let __ret: [G; OUT_152] = [__v_3];
-    record.function_queries[152].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],
-  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 __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; 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: 47 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 47] = __args[..47].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];
-    let __v_12: G = __loaded[10];
-    let __v_13: G = __loaded[11];
-    let __v_14: G = __loaded[12];
-    let __v_15: G = __loaded[13];
-    let __v_16: G = __loaded[14];
-    let __v_17: G = __loaded[15];
-    let __v_18: G = __loaded[16];
-    let __v_19: G = __loaded[17];
-    let __v_20: G = __loaded[18];
-    let __v_21: G = __loaded[19];
-    let __v_22: G = __loaded[20];
-    let __v_23: G = __loaded[21];
-    let __v_24: G = __loaded[22];
-    let __v_25: G = __loaded[23];
-    let __v_26: G = __loaded[24];
-    let __v_27: G = __loaded[25];
-    let __v_28: G = __loaded[26];
-    let __v_29: G = __loaded[27];
-    let __v_30: G = __loaded[28];
-    let __v_31: G = __loaded[29];
-    let __v_32: G = __loaded[30];
-    let __v_33: G = __loaded[31];
-    let __v_34: G = __loaded[32];
-    let __v_35: G = __loaded[33];
-    let __v_36: G = __loaded[34];
-    let __v_37: G = __loaded[35];
-    let __v_38: G = __loaded[36];
-    let __v_39: G = __loaded[37];
-    let __v_40: G = __loaded[38];
-    let __v_41: G = __loaded[39];
-    let __v_42: G = __loaded[40];
-    let __v_43: G = __loaded[41];
-    let __v_44: G = __loaded[42];
-    let __v_45: G = __loaded[43];
-    let __v_46: G = __loaded[44];
-    let __v_47: G = __loaded[45];
-    let __v_48: G = __loaded[46];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
-        let __v_49: G = G::from_u64(1);
-        let __v_50: G = G::from_u64(1);
-        let __v_51: G = { let __values: [G; 3] = [__v_49, __v_50, __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 __ret: [G; OUT_153] = [__v_51];
-        record.function_queries[153].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __v_49: G = G::from_u64(0);
-        let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__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_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]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { 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_50: G = __r_arr[0];
-        let __v_51: G = (__v_1 + __v_50);
-        let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = [__v_48, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[153].get_mut(&__args[..]) { 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 __v_53: G = { let __values: [G; 3] = [__v_49, __v_1, __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 __ret: [G; OUT_153] = [__v_53];
-        record.function_queries[153].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_154: usize = 3;
-const IN_154: usize = 3;
-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 __v_2: G = inp[2];
-    match __v_0.as_canonical_u64() {
-      0u64 => {
-        let __v_3: G = G::from_u64(1);
-        let __v_4: G = G::from_u64(1);
-        let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __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 __ret: [G; OUT_154] = [__v_5];
-        record.function_queries[154].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(1);
-        let __v_5: G = (__v_4 + __v_2);
-        let __v_6: G = (__v_1 + __v_5);
-        let __v_7: G = G::from_u64(1);
-        let __v_8: G = (__v_0 - __v_7);
-        let __v_9: G = G::from_u64(1);
-        let __v_10: G = (__v_2 + __v_9);
-        let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_8, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[154].get_mut(&__args[..]) { 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 __v_12: G = { let __values: [G; 3] = [__v_3, __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_154] = [__v_12];
-        record.function_queries[154].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_155: usize = 3;
-const IN_155: usize = 3;
-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 __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { 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_3: G = __r_arr[0];
-    let __ret: [G; OUT_155] = [__v_3];
-    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 __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; 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: 47 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 47] = __args[..47].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];
-    let __v_12: G = __loaded[10];
-    let __v_13: G = __loaded[11];
-    let __v_14: G = __loaded[12];
-    let __v_15: G = __loaded[13];
-    let __v_16: G = __loaded[14];
-    let __v_17: G = __loaded[15];
-    let __v_18: G = __loaded[16];
-    let __v_19: G = __loaded[17];
-    let __v_20: G = __loaded[18];
-    let __v_21: G = __loaded[19];
-    let __v_22: G = __loaded[20];
-    let __v_23: G = __loaded[21];
-    let __v_24: G = __loaded[22];
-    let __v_25: G = __loaded[23];
-    let __v_26: G = __loaded[24];
-    let __v_27: G = __loaded[25];
-    let __v_28: G = __loaded[26];
-    let __v_29: G = __loaded[27];
-    let __v_30: G = __loaded[28];
-    let __v_31: G = __loaded[29];
-    let __v_32: G = __loaded[30];
-    let __v_33: G = __loaded[31];
-    let __v_34: G = __loaded[32];
-    let __v_35: G = __loaded[33];
-    let __v_36: G = __loaded[34];
-    let __v_37: G = __loaded[35];
-    let __v_38: G = __loaded[36];
-    let __v_39: G = __loaded[37];
-    let __v_40: G = __loaded[38];
-    let __v_41: G = __loaded[39];
-    let __v_42: G = __loaded[40];
-    let __v_43: G = __loaded[41];
-    let __v_44: G = __loaded[42];
-    let __v_45: G = __loaded[43];
-    let __v_46: G = __loaded[44];
-    let __v_47: G = __loaded[45];
-    let __v_48: G = __loaded[46];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
-        let __v_49: G = G::from_u64(1);
-        let __v_50: G = G::from_u64(1);
-        let __v_51: G = { let __values: [G; 3] = [__v_49, __v_50, __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 __ret: [G; OUT_156] = [__v_51];
-        record.function_queries[156].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      0u64 => {
-        match __v_3.as_canonical_u64() {
-          1u64 => {
-            match __v_4.as_canonical_u64() {
-              _ => {
-                let __r_arr: [G; OUT_793] = { let __args: [G; IN_793] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[793].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_793] = unsafe { *(result.output.as_ptr() as *const [G; OUT_793]) }; __ret } else { aiur_fn_793(__args, record, io_buffer, __cu)? } };
-                let __v_49: G = __r_arr[0];
-                let __v_50: G = G::from_u64(0);
-                let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_49, __v_1, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[154].get_mut(&__args[..]) { 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_51: G = __r_arr[0];
-                let __v_52: G = G::from_u64(1);
-                let __v_53: G = (__v_52 + __v_49);
-                let __v_54: G = (__v_1 + __v_53);
-                let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_48, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { 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_55: G = __r_arr[0];
-                let __r_arr: [G; OUT_773] = { let __args: [G; IN_773] = [__v_51, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[773].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_773] = unsafe { *(result.output.as_ptr() as *const [G; OUT_773]) }; __ret } else { aiur_fn_773(__args, record, io_buffer, __cu)? } };
-                let __v_56: G = __r_arr[0];
-                let __ret: [G; OUT_156] = [__v_56];
-                record.function_queries[156].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-            }
-          },
-          0u64 => {
-            let __v_49: G = G::from_u64(1);
-            let __v_50: G = (__v_1 + __v_49);
-            let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_48, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { 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_51: G = __r_arr[0];
-            let __ret: [G; OUT_156] = [__v_51];
-            record.function_queries[156].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          2u64 => {
-            let __v_49: G = G::from_u64(1);
-            let __v_50: G = (__v_1 + __v_49);
-            let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_48, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { 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_51: G = __r_arr[0];
-            let __ret: [G; OUT_156] = [__v_51];
-            record.function_queries[156].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
-          },
-        }
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-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 __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; 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: 47 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 47] = __args[..47].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 __v_35: G = __loaded[34];
-    let __v_36: G = __loaded[35];
-    let __v_37: G = __loaded[36];
-    let __v_38: G = __loaded[37];
-    let __v_39: G = __loaded[38];
-    let __v_40: G = __loaded[39];
-    let __v_41: G = __loaded[40];
-    let __v_42: G = __loaded[41];
-    let __v_43: G = __loaded[42];
-    let __v_44: G = __loaded[43];
-    let __v_45: G = __loaded[44];
-    let __v_46: G = __loaded[45];
-    let __v_47: G = __loaded[46];
-    match __v_1.as_canonical_u64() {
-      1u64 => {
-        let __v_48: G = G::from_u64(0);
-        let __ret: [G; OUT_157] = [__v_48];
-        record.function_queries[157].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      0u64 => {
-        match __v_2.as_canonical_u64() {
-          1u64 => {
-            let __v_48: G = G::from_u64(1);
-            let __ret: [G; OUT_157] = [__v_48];
-            record.function_queries[157].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = [__v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[157].get_mut(&__args[..]) { 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_48: G = __r_arr[0];
-            let __ret: [G; OUT_157] = [__v_48];
-            record.function_queries[157].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-        }
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_158: usize = 19;
-const IN_158: usize = 19;
-const OUT_158: usize = 18;
-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];
-    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];
-    match __v_0.as_canonical_u64() {
-      11u64 => {
-        let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__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[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } };
-        let __v_19: G = __r_arr[0];
-        let __r_arr: [G; OUT_796] = { let __args: [G; IN_796] = [__v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[796].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_796] = unsafe { *(result.output.as_ptr() as *const [G; OUT_796]) }; __ret } else { aiur_fn_796(__args, record, io_buffer, __cu)? } };
-        let __v_20: 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_20.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).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 __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; 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: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr };
-            let __v_24: G = __loaded[0];
-            let __v_25: G = __loaded[1];
-            let __v_26: G = __loaded[2];
-            let __v_27: G = __loaded[3];
-            let __v_28: G = __loaded[4];
-            let __v_29: G = __loaded[5];
-            let __v_30: G = __loaded[6];
-            let __v_31: G = __loaded[7];
-            let __v_32: G = __loaded[8];
-            let __v_33: G = __loaded[9];
-            let __v_34: G = __loaded[10];
-            let __v_35: G = __loaded[11];
-            let __v_36: G = __loaded[12];
-            let __v_37: G = __loaded[13];
-            let __v_38: G = __loaded[14];
-            let __v_39: G = __loaded[15];
-            let __v_40: G = __loaded[16];
-            let __v_41: G = __loaded[17];
-            let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__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_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { 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_42: G = __r_arr[0];
-            let __v_43: G = __r_arr[1];
-            let __v_44: G = __r_arr[2];
-            let __v_45: G = __r_arr[3];
-            let __v_46: G = __r_arr[4];
-            let __v_47: G = __r_arr[5];
-            let __v_48: G = __r_arr[6];
-            let __v_49: G = __r_arr[7];
-            let __v_50: G = __r_arr[8];
-            let __v_51: G = __r_arr[9];
-            let __v_52: G = __r_arr[10];
-            let __v_53: G = __r_arr[11];
-            let __v_54: G = __r_arr[12];
-            let __v_55: G = __r_arr[13];
-            let __v_56: G = __r_arr[14];
-            let __v_57: G = __r_arr[15];
-            let __v_58: G = __r_arr[16];
-            let __v_59: G = __r_arr[17];
-            let __ret: [G; OUT_158] = [__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];
-            record.function_queries[158].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_21.as_canonical_u64()));
-          },
-        }
-      },
-      _ => {
-        let __ret: [G; OUT_158] = [__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];
-        record.function_queries[158].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_159: usize = 20;
-const IN_159: usize = 20;
-const OUT_159: usize = 18;
-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];
-    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];
-    match __v_18.as_canonical_u64() {
-      0u64 => {
-        let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__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_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { 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_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 __ret: [G; OUT_159] = [__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];
-        record.function_queries[159].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__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_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { 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_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];
-        match __v_20.as_canonical_u64() {
-          9u64 => {
-            let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; 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: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr };
-            let __v_38: G = __loaded[0];
-            let __v_39: G = __loaded[1];
-            let __v_40: G = __loaded[2];
-            let __v_41: G = __loaded[3];
-            let __v_42: G = __loaded[4];
-            let __v_43: G = __loaded[5];
-            let __v_44: G = __loaded[6];
-            let __v_45: G = __loaded[7];
-            let __v_46: G = __loaded[8];
-            let __v_47: G = __loaded[9];
-            let __v_48: G = __loaded[10];
-            let __v_49: G = __loaded[11];
-            let __v_50: G = __loaded[12];
-            let __v_51: G = __loaded[13];
-            let __v_52: G = __loaded[14];
-            let __v_53: G = __loaded[15];
-            let __v_54: G = __loaded[16];
-            let __v_55: G = __loaded[17];
-            let __v_56: G = G::from_u64(1);
-            let __v_57: G = (__v_18 - __v_56);
-            let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__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_57, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { 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_58: G = __r_arr[0];
-            let __v_59: G = __r_arr[1];
-            let __v_60: G = __r_arr[2];
-            let __v_61: G = __r_arr[3];
-            let __v_62: G = __r_arr[4];
-            let __v_63: G = __r_arr[5];
-            let __v_64: G = __r_arr[6];
-            let __v_65: G = __r_arr[7];
-            let __v_66: G = __r_arr[8];
-            let __v_67: G = __r_arr[9];
-            let __v_68: G = __r_arr[10];
-            let __v_69: G = __r_arr[11];
-            let __v_70: G = __r_arr[12];
-            let __v_71: G = __r_arr[13];
-            let __v_72: G = __r_arr[14];
-            let __v_73: G = __r_arr[15];
-            let __v_74: G = __r_arr[16];
-            let __v_75: G = __r_arr[17];
-            let __ret: [G; OUT_159] = [__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];
-            record.function_queries[159].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            let __ret: [G; OUT_159] = [__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];
-            record.function_queries[159].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-        }
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_160: usize = 19;
-const IN_160: usize = 19;
-const OUT_160: usize = 18;
-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];
-    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 __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__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]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { 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_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 __v_28: G = __r_arr[9];
-    let __v_29: G = __r_arr[10];
-    let __v_30: G = __r_arr[11];
-    let __v_31: G = __r_arr[12];
-    let __v_32: G = __r_arr[13];
-    let __v_33: G = __r_arr[14];
-    let __v_34: G = __r_arr[15];
-    let __v_35: G = __r_arr[16];
-    let __v_36: G = __r_arr[17];
-    match __v_19.as_canonical_u64() {
-      7u64 => {
-        let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_20.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr };
-        let __v_37: G = __loaded[0];
-        let __v_38: G = __loaded[1];
-        let __v_39: G = __loaded[2];
-        let __v_40: G = __loaded[3];
-        let __v_41: G = __loaded[4];
-        let __v_42: G = __loaded[5];
-        let __v_43: G = __loaded[6];
-        let __v_44: G = __loaded[7];
-        let __v_45: G = __loaded[8];
-        let __v_46: G = __loaded[9];
-        let __v_47: G = __loaded[10];
-        let __v_48: G = __loaded[11];
-        let __v_49: G = __loaded[12];
-        let __v_50: G = __loaded[13];
-        let __v_51: G = __loaded[14];
-        let __v_52: G = __loaded[15];
-        let __v_53: G = __loaded[16];
-        let __v_54: G = __loaded[17];
-        let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = [__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_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[160].get_mut(&__args[..]) { 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_55: G = __r_arr[0];
-        let __v_56: G = __r_arr[1];
-        let __v_57: G = __r_arr[2];
-        let __v_58: G = __r_arr[3];
-        let __v_59: G = __r_arr[4];
-        let __v_60: G = __r_arr[5];
-        let __v_61: G = __r_arr[6];
-        let __v_62: G = __r_arr[7];
-        let __v_63: G = __r_arr[8];
-        let __v_64: G = __r_arr[9];
-        let __v_65: G = __r_arr[10];
-        let __v_66: G = __r_arr[11];
-        let __v_67: G = __r_arr[12];
-        let __v_68: G = __r_arr[13];
-        let __v_69: G = __r_arr[14];
-        let __v_70: G = __r_arr[15];
-        let __v_71: G = __r_arr[16];
-        let __v_72: G = __r_arr[17];
-        let __ret: [G; OUT_160] = [__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];
-        record.function_queries[160].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__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]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { 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 = __r_arr[1];
-        let __v_39: G = __r_arr[2];
-        let __v_40: G = __r_arr[3];
-        let __v_41: G = __r_arr[4];
-        let __v_42: G = __r_arr[5];
-        let __v_43: G = __r_arr[6];
-        let __v_44: G = __r_arr[7];
-        let __v_45: G = __r_arr[8];
-        let __v_46: G = __r_arr[9];
-        let __v_47: G = __r_arr[10];
-        let __v_48: G = __r_arr[11];
-        let __v_49: G = __r_arr[12];
-        let __v_50: G = __r_arr[13];
-        let __v_51: G = __r_arr[14];
-        let __v_52: G = __r_arr[15];
-        let __v_53: G = __r_arr[16];
-        let __v_54: G = __r_arr[17];
-        let __ret: [G; OUT_160] = [__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];
-        record.function_queries[160].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_161: usize = 21;
-const IN_161: usize = 21;
-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];
-    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 __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__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_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { 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_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 __v_31: G = __r_arr[10];
-    let __v_32: G = __r_arr[11];
-    let __v_33: G = __r_arr[12];
-    let __v_34: G = __r_arr[13];
-    let __v_35: G = __r_arr[14];
-    let __v_36: G = __r_arr[15];
-    let __v_37: G = __r_arr[16];
-    let __v_38: G = __r_arr[17];
-    match __v_21.as_canonical_u64() {
-      9u64 => {
-        let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; 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: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr };
-        let __v_39: G = __loaded[0];
-        let __v_40: G = __loaded[1];
-        let __v_41: G = __loaded[2];
-        let __v_42: G = __loaded[3];
-        let __v_43: G = __loaded[4];
-        let __v_44: G = __loaded[5];
-        let __v_45: G = __loaded[6];
-        let __v_46: G = __loaded[7];
-        let __v_47: G = __loaded[8];
-        let __v_48: G = __loaded[9];
-        let __v_49: G = __loaded[10];
-        let __v_50: G = __loaded[11];
-        let __v_51: G = __loaded[12];
-        let __v_52: G = __loaded[13];
-        let __v_53: G = __loaded[14];
-        let __v_54: G = __loaded[15];
-        let __v_55: G = __loaded[16];
-        let __v_56: G = __loaded[17];
-        let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = [__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_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[160].get_mut(&__args[..]) { 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_57: G = __r_arr[0];
-        let __v_58: G = __r_arr[1];
-        let __v_59: G = __r_arr[2];
-        let __v_60: G = __r_arr[3];
-        let __v_61: G = __r_arr[4];
-        let __v_62: G = __r_arr[5];
-        let __v_63: G = __r_arr[6];
-        let __v_64: G = __r_arr[7];
-        let __v_65: G = __r_arr[8];
-        let __v_66: G = __r_arr[9];
-        let __v_67: G = __r_arr[10];
-        let __v_68: G = __r_arr[11];
-        let __v_69: G = __r_arr[12];
-        let __v_70: G = __r_arr[13];
-        let __v_71: G = __r_arr[14];
-        let __v_72: G = __r_arr[15];
-        let __v_73: G = __r_arr[16];
-        let __v_74: G = __r_arr[17];
-        match __v_57.as_canonical_u64() {
-          2u64 => {
-            let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } };
-            let __v_75: G = __r_arr[0];
-            let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_19, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-            let __v_76: G = __r_arr[0];
-            let __ret: [G; OUT_161] = [__v_76];
-            record.function_queries[161].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            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 = { let __values: [G; 32] = [__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]; 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_161] = [__v_107];
-            record.function_queries[161].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-        }
-      },
-      _ => {
-        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 = G::from_u64(0);
-        let __v_49: G = G::from_u64(0);
-        let __v_50: G = G::from_u64(0);
-        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 = { let __values: [G; 32] = [__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]; 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_161] = [__v_71];
-        record.function_queries[161].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_162: usize = 48;
-const IN_162: usize = 48;
-const OUT_162: usize = 2;
-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];
-    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];
-    match __v_0.as_canonical_u64() {
-      _ => {
-        let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; 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: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr };
-        let __v_48: G = __loaded[0];
-        let __v_49: G = __loaded[1];
-        let __v_50: G = __loaded[2];
-        let __v_51: G = __loaded[3];
-        let __v_52: G = __loaded[4];
-        let __v_53: G = __loaded[5];
-        let __v_54: G = __loaded[6];
-        let __v_55: G = __loaded[7];
-        let __v_56: G = __loaded[8];
-        let __v_57: G = __loaded[9];
-        let __v_58: G = __loaded[10];
-        let __v_59: G = __loaded[11];
-        let __v_60: G = __loaded[12];
-        let __v_61: G = __loaded[13];
-        let __v_62: G = __loaded[14];
-        let __v_63: G = __loaded[15];
-        let __v_64: G = __loaded[16];
-        let __v_65: G = __loaded[17];
-        let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } };
-        let __v_66: G = __r_arr[0];
-        let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } };
-        let __v_67: G = __r_arr[0];
-        let __v_68: G = (__v_66 + __v_67);
-        let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } };
-        let __v_69: G = __r_arr[0];
-        let __v_70: G = (__v_68 + __v_69);
-        let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } };
-        let __v_71: G = __r_arr[0];
-        let __v_72: G = (__v_70 + __v_71);
-        let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__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_72, __v_44, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { 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_73: G = __r_arr[0];
-        let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_73]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { 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_74: G = __r_arr[0];
-        let __v_75: G = __r_arr[1];
-        let __v_76: G = __r_arr[2];
-        let __v_77: G = __r_arr[3];
-        let __v_78: G = __r_arr[4];
-        let __v_79: G = __r_arr[5];
-        let __v_80: G = __r_arr[6];
-        let __v_81: G = __r_arr[7];
-        let __v_82: G = __r_arr[8];
-        let __v_83: G = __r_arr[9];
-        let __v_84: G = __r_arr[10];
-        let __v_85: G = __r_arr[11];
-        let __v_86: G = __r_arr[12];
-        let __v_87: G = __r_arr[13];
-        let __v_88: G = __r_arr[14];
-        let __v_89: G = __r_arr[15];
-        let __v_90: G = __r_arr[16];
-        let __v_91: G = __r_arr[17];
-        let __v_92: G = __r_arr[18];
-        let __v_93: G = __r_arr[19];
-        let __v_94: G = __r_arr[20];
-        let __v_95: G = __r_arr[21];
-        let __v_96: G = __r_arr[22];
-        let __v_97: G = __r_arr[23];
-        let __v_98: G = __r_arr[24];
-        let __v_99: G = __r_arr[25];
-        let __v_100: G = __r_arr[26];
-        let __v_101: G = __r_arr[27];
-        let __v_102: G = __r_arr[28];
-        let __v_103: G = __r_arr[29];
-        let __v_104: G = __r_arr[30];
-        let __v_105: G = __r_arr[31];
-        let __v_106: G = __r_arr[32];
-        let __v_107: G = __r_arr[33];
-        let __v_108: G = __r_arr[34];
-        let __v_109: G = __r_arr[35];
-        let __v_110: G = __r_arr[36];
-        let __v_111: G = __r_arr[37];
-        let __v_112: G = __r_arr[38];
-        let __v_113: G = __r_arr[39];
-        let __v_114: G = __r_arr[40];
-        let __v_115: G = __r_arr[41];
-        let __v_116: G = __r_arr[42];
-        let __v_117: G = __r_arr[43];
-        let __v_118: G = __r_arr[44];
-        let __v_119: G = __r_arr[45];
-        let __v_120: G = __r_arr[46];
-        let __v_121: G = __r_arr[47];
-        match __v_74.as_canonical_u64() {
-          _ => {
-            match __v_74.as_canonical_u64() {
-              6u64 => {
-                match __v_75.as_canonical_u64() {
-                  _ => {
-                    let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_83]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { 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_122: G = __r_arr[0];
-                    let __v_123: G = __r_arr[1];
-                    let __v_124: G = __r_arr[2];
-                    let __v_125: G = __r_arr[3];
-                    let __v_126: G = __r_arr[4];
-                    let __v_127: G = __r_arr[5];
-                    let __v_128: G = __r_arr[6];
-                    let __v_129: G = __r_arr[7];
-                    let __v_130: G = __r_arr[8];
-                    let __v_131: G = __r_arr[9];
-                    let __v_132: G = __r_arr[10];
-                    let __v_133: G = __r_arr[11];
-                    let __v_134: G = __r_arr[12];
-                    let __v_135: G = __r_arr[13];
-                    let __v_136: G = __r_arr[14];
-                    let __v_137: G = __r_arr[15];
-                    let __v_138: G = __r_arr[16];
-                    let __v_139: G = __r_arr[17];
-                    let __v_140: G = __r_arr[18];
-                    let __v_141: G = __r_arr[19];
-                    let __v_142: G = __r_arr[20];
-                    let __v_143: G = __r_arr[21];
-                    let __v_144: G = __r_arr[22];
-                    let __v_145: G = __r_arr[23];
-                    let __v_146: G = __r_arr[24];
-                    let __v_147: G = __r_arr[25];
-                    let __v_148: G = __r_arr[26];
-                    let __v_149: G = __r_arr[27];
-                    let __v_150: G = __r_arr[28];
-                    let __v_151: G = __r_arr[29];
-                    let __v_152: G = __r_arr[30];
-                    let __v_153: G = __r_arr[31];
-                    let __v_154: G = __r_arr[32];
-                    let __v_155: G = __r_arr[33];
-                    let __v_156: G = __r_arr[34];
-                    let __v_157: G = __r_arr[35];
-                    let __v_158: G = __r_arr[36];
-                    let __v_159: G = __r_arr[37];
-                    let __v_160: G = __r_arr[38];
-                    let __v_161: G = __r_arr[39];
-                    let __v_162: G = __r_arr[40];
-                    let __v_163: G = __r_arr[41];
-                    let __v_164: G = __r_arr[42];
-                    let __v_165: G = __r_arr[43];
-                    let __v_166: G = __r_arr[44];
-                    let __v_167: G = __r_arr[45];
-                    let __v_168: G = __r_arr[46];
-                    let __v_169: G = __r_arr[47];
-                    match __v_122.as_canonical_u64() {
-                      _ => {
-                        match __v_122.as_canonical_u64() {
-                          8u64 => {
-                            let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_83, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[135].get_mut(&__args[..]) { 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_170: G = __r_arr[0];
-                            let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } };
-                            let __v_171: G = __r_arr[0];
-                            let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = [__v_123, __v_170, __v_171]; let __cu = unconstrained; if let Some(result) = record.function_queries[163].get_mut(&__args[..]) { 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_172: G = __r_arr[0];
-                            let __ret: [G; OUT_162] = [__v_172, __v_83];
-                            record.function_queries[162].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                            return Ok(__ret);
-                          },
-                          _ => {
-                            return Err(ExecError::MatchNoCase(__v_122.as_canonical_u64()));
-                          },
-                        }
-                      },
-                    }
-                  },
-                }
-              },
-              _ => {
-                return Err(ExecError::MatchNoCase(__v_74.as_canonical_u64()));
-              },
-            }
-          },
-        }
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_163: usize = 3;
-const IN_163: usize = 3;
-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 __v_1: G = inp[1];
-    let __v_2: G = inp[2];
-    let __v_3: G = G::from_u64(0);
-    let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { 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 __ret: [G; OUT_163] = [__v_4];
-    record.function_queries[163].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_164: usize = 4;
-const IN_164: usize = 4;
-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 __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; 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: 47 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr };
-    let __v_4: G = __loaded[0];
-    let __v_5: G = __loaded[1];
-    let __v_6: G = __loaded[2];
-    let __v_7: G = __loaded[3];
-    let __v_8: G = __loaded[4];
-    let __v_9: G = __loaded[5];
-    let __v_10: G = __loaded[6];
-    let __v_11: G = __loaded[7];
-    let __v_12: G = __loaded[8];
-    let __v_13: G = __loaded[9];
-    let __v_14: G = __loaded[10];
-    let __v_15: G = __loaded[11];
-    let __v_16: G = __loaded[12];
-    let __v_17: G = __loaded[13];
-    let __v_18: G = __loaded[14];
-    let __v_19: G = __loaded[15];
-    let __v_20: G = __loaded[16];
-    let __v_21: G = __loaded[17];
-    let __v_22: G = __loaded[18];
-    let __v_23: G = __loaded[19];
-    let __v_24: G = __loaded[20];
-    let __v_25: G = __loaded[21];
-    let __v_26: G = __loaded[22];
-    let __v_27: G = __loaded[23];
-    let __v_28: G = __loaded[24];
-    let __v_29: G = __loaded[25];
-    let __v_30: G = __loaded[26];
-    let __v_31: G = __loaded[27];
-    let __v_32: G = __loaded[28];
-    let __v_33: G = __loaded[29];
-    let __v_34: G = __loaded[30];
-    let __v_35: G = __loaded[31];
-    let __v_36: G = __loaded[32];
-    let __v_37: G = __loaded[33];
-    let __v_38: G = __loaded[34];
-    let __v_39: G = __loaded[35];
-    let __v_40: G = __loaded[36];
-    let __v_41: G = __loaded[37];
-    let __v_42: G = __loaded[38];
-    let __v_43: G = __loaded[39];
-    let __v_44: G = __loaded[40];
-    let __v_45: G = __loaded[41];
-    let __v_46: G = __loaded[42];
-    let __v_47: G = __loaded[43];
-    let __v_48: G = __loaded[44];
-    let __v_49: G = __loaded[45];
-    let __v_50: G = __loaded[46];
-    match __v_4.as_canonical_u64() {
-      1u64 => {
-        let __v_51: G = G::from_u64(1);
-        let __v_52: G = G::from_u64(1);
-        let __v_53: G = { let __values: [G; 3] = [__v_51, __v_52, __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 __ret: [G; OUT_164] = [__v_53];
-        record.function_queries[164].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__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, __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]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { 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_51: G = __r_arr[0];
-        let __v_52: G = (__v_3 - __v_2);
-        let __v_53: G = G::from_bool((__v_52 == G::ZERO));
-        match __v_53.as_canonical_u64() {
-          1u64 => {
-            match __v_5.as_canonical_u64() {
-              1u64 => {
-                match __v_6.as_canonical_u64() {
-                  _ => {
-                    let __r_arr: [G; OUT_793] = { let __args: [G; IN_793] = [__v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[793].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_793] = unsafe { *(result.output.as_ptr() as *const [G; OUT_793]) }; __ret } else { aiur_fn_793(__args, record, io_buffer, __cu)? } };
-                    let __v_54: G = __r_arr[0];
-                    let __v_55: G = G::from_u64(0);
-                    let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_54, __v_1, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[154].get_mut(&__args[..]) { 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_56: G = __r_arr[0];
-                    let __ret: [G; OUT_164] = [__v_56];
-                    record.function_queries[164].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
-                }
-              },
-              _ => {
-                let __v_54: G = G::from_u64(1);
-                let __v_55: G = G::from_u64(1);
-                let __v_56: G = { let __values: [G; 3] = [__v_54, __v_55, __v_55]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_56];
-                record.function_queries[164].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-            }
-          },
-          0u64 => {
-            let __v_54: G = (__v_1 + __v_51);
-            let __v_55: G = G::from_u64(1);
-            let __v_56: G = (__v_3 + __v_55);
-            let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_50, __v_54, __v_2, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { 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_57: G = __r_arr[0];
-            let __ret: [G; OUT_164] = [__v_57];
-            record.function_queries[164].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_53.as_canonical_u64()));
-          },
-        }
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_165: usize = 57;
-const IN_165: usize = 57;
-const OUT_165: usize = 1;
-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];
-    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];
-    match __v_0.as_canonical_u64() {
-      1u64 => {
-        match __v_1.as_canonical_u64() {
-          _ => {
-            let __r_arr: [G; OUT_793] = { let __args: [G; IN_793] = [__v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[793].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_793] = unsafe { *(result.output.as_ptr() as *const [G; OUT_793]) }; __ret } else { aiur_fn_793(__args, record, io_buffer, __cu)? } };
-            let __v_57: G = __r_arr[0];
-            let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_50, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[128].get_mut(&__args[..]) { 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_58: G = __r_arr[0];
-            let __v_59: G = (__v_51 + __v_58);
-            let __v_60: G = G::from_u64(0);
-            let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_57, __v_59, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[154].get_mut(&__args[..]) { 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_61: G = __r_arr[0];
-            let __v_62: G = G::from_u64(4);
-            let __v_63: G = G::from_u64(0);
-            let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = [__v_27, __v_45, __v_46, __v_47, __v_48, __v_49, __v_59]; let __cu = unconstrained; if let Some(result) = record.function_queries[166].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_166] = unsafe { *(result.output.as_ptr() as *const [G; OUT_166]) }; __ret } else { aiur_fn_166(__args, record, io_buffer, __cu)? } };
-            let __v_64: G = __r_arr[0];
-            let __v_65: G = G::from_u64(0);
-            let __v_66: G = { let __values: [G; 52] = [__v_45, __v_46, __v_47, __v_48, __v_49, __v_62, __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_61, __v_56, __v_63, __v_63, __v_63, __v_63, __v_63, __v_63, __v_63, __v_63, __v_63, __v_63, __v_63, __v_63, __v_63, __v_63, __v_63, __v_63, __v_63]; let __mq = record.memory_queries.get_mut(&52).ok_or(ExecError::InvalidMemorySize(52))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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; 3] = [__v_65, __v_66, __v_64]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_165] = [__v_67];
-            record.function_queries[165].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-        }
-      },
-      2u64 => {
-        let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = [__v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[157].get_mut(&__args[..]) { 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_57: G = __r_arr[0];
-        match __v_57.as_canonical_u64() {
-          1u64 => {
-            let __v_58: G = G::from_u64(0);
-            let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_50, __v_51, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[155].get_mut(&__args[..]) { 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_59: G = __r_arr[0];
-            let __v_60: G = G::from_u64(3);
-            let __v_61: G = G::from_u64(0);
-            let __v_62: G = { let __values: [G; 52] = [__v_45, __v_46, __v_47, __v_48, __v_49, __v_60, __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_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_59, __v_56]; let __mq = record.memory_queries.get_mut(&52).ok_or(ExecError::InvalidMemorySize(52))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __v_63: G = G::from_u64(1);
-            let __v_64: G = G::from_u64(1);
-            let __v_65: G = { let __values: [G; 3] = [__v_63, __v_64, __v_64]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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; 3] = [__v_61, __v_62, __v_65]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_165] = [__v_66];
-            record.function_queries[165].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          0u64 => {
-            let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_45.as_canonical_u64() {
-  _ => {
-    break '__mc_0 [__v_45];
-  },
-}
- };
-            let __v_58: G = __mc_out___mc_0[0];
-            let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__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_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_53, __v_58, __v_54, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { 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_59: G = __r_arr[0];
-            let __v_60: G = __r_arr[1];
-            let __v_61: G = G::from_u64(3);
-            let __v_62: G = G::from_u64(0);
-            let __v_63: G = { let __values: [G; 52] = [__v_45, __v_46, __v_47, __v_48, __v_49, __v_61, __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_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_59, __v_56]; let __mq = record.memory_queries.get_mut(&52).ok_or(ExecError::InvalidMemorySize(52))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __v_64: G = G::from_u64(1);
-            let __v_65: G = G::from_u64(1);
-            let __v_66: G = { let __values: [G; 3] = [__v_64, __v_65, __v_65]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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; 3] = [__v_62, __v_63, __v_66]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_165] = [__v_67];
-            record.function_queries[165].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_57.as_canonical_u64()));
-          },
-        }
-      },
-      0u64 => {
-        let __v_57: G = G::from_u64(0);
-        let __v_58: G = G::from_u64(1);
-        let __v_59: G = G::from_u64(0);
-        let __v_60: G = G::from_u64(0);
-        let __v_61: G = { let __values: [G; 52] = [__v_45, __v_46, __v_47, __v_48, __v_49, __v_57, __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_58, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59]; let __mq = record.memory_queries.get_mut(&52).ok_or(ExecError::InvalidMemorySize(52))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_62: G = G::from_u64(1);
-        let __v_63: G = G::from_u64(1);
-        let __v_64: G = { let __values: [G; 3] = [__v_62, __v_63, __v_63]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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; 3] = [__v_60, __v_61, __v_64]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_165] = [__v_65];
-        record.function_queries[165].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_166: usize = 7;
-const IN_166: usize = 7;
-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 __v_4: G = inp[4];
-    let __v_5: G = inp[5];
-    let __v_6: G = inp[6];
-    let __loaded: [G; 36] = { let __mq = record.memory_queries.get_mut(&36).ok_or(ExecError::InvalidMemorySize(36))?; 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: 36 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 36] = __args[..36].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];
-    let __v_17: G = __loaded[10];
-    let __v_18: G = __loaded[11];
-    let __v_19: G = __loaded[12];
-    let __v_20: G = __loaded[13];
-    let __v_21: G = __loaded[14];
-    let __v_22: G = __loaded[15];
-    let __v_23: G = __loaded[16];
-    let __v_24: G = __loaded[17];
-    let __v_25: G = __loaded[18];
-    let __v_26: G = __loaded[19];
-    let __v_27: G = __loaded[20];
-    let __v_28: G = __loaded[21];
-    let __v_29: G = __loaded[22];
-    let __v_30: G = __loaded[23];
-    let __v_31: G = __loaded[24];
-    let __v_32: G = __loaded[25];
-    let __v_33: G = __loaded[26];
-    let __v_34: G = __loaded[27];
-    let __v_35: G = __loaded[28];
-    let __v_36: G = __loaded[29];
-    let __v_37: G = __loaded[30];
-    let __v_38: G = __loaded[31];
-    let __v_39: G = __loaded[32];
-    let __v_40: G = __loaded[33];
-    let __v_41: G = __loaded[34];
-    let __v_42: G = __loaded[35];
-    match __v_7.as_canonical_u64() {
-      1u64 => {
-        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 __ret: [G; OUT_166] = [__v_45];
-        record.function_queries[166].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __v_43: G = G::from_u64(5);
-        let __v_44: G = G::from_u64(0);
-        let __v_45: G = G::from_u64(0);
-        let __v_46: G = { let __values: [G; 52] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_43, __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, __v_37, __v_38, __v_39, __v_40, __v_41, __v_6, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44]; let __mq = record.memory_queries.get_mut(&52).ok_or(ExecError::InvalidMemorySize(52))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_166] = { let __args: [G; IN_166] = [__v_42, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[166].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_166] = unsafe { *(result.output.as_ptr() as *const [G; OUT_166]) }; __ret } else { aiur_fn_166(__args, record, io_buffer, __cu)? } };
-        let __v_47: G = __r_arr[0];
-        let __v_48: G = { let __values: [G; 3] = [__v_45, __v_46, __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 __ret: [G; OUT_166] = [__v_48];
-        record.function_queries[166].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_167: usize = 13;
-const IN_167: usize = 13;
-const OUT_167: usize = 1;
-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 __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 __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; 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: 47 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr };
-    let __v_13: G = __loaded[0];
-    let __v_14: G = __loaded[1];
-    let __v_15: G = __loaded[2];
-    let __v_16: G = __loaded[3];
-    let __v_17: G = __loaded[4];
-    let __v_18: G = __loaded[5];
-    let __v_19: G = __loaded[6];
-    let __v_20: G = __loaded[7];
-    let __v_21: G = __loaded[8];
-    let __v_22: G = __loaded[9];
-    let __v_23: G = __loaded[10];
-    let __v_24: G = __loaded[11];
-    let __v_25: G = __loaded[12];
-    let __v_26: G = __loaded[13];
-    let __v_27: G = __loaded[14];
-    let __v_28: G = __loaded[15];
-    let __v_29: G = __loaded[16];
-    let __v_30: G = __loaded[17];
-    let __v_31: G = __loaded[18];
-    let __v_32: G = __loaded[19];
-    let __v_33: G = __loaded[20];
-    let __v_34: G = __loaded[21];
-    let __v_35: G = __loaded[22];
-    let __v_36: G = __loaded[23];
-    let __v_37: G = __loaded[24];
-    let __v_38: G = __loaded[25];
-    let __v_39: G = __loaded[26];
-    let __v_40: G = __loaded[27];
-    let __v_41: G = __loaded[28];
-    let __v_42: G = __loaded[29];
-    let __v_43: G = __loaded[30];
-    let __v_44: G = __loaded[31];
-    let __v_45: G = __loaded[32];
-    let __v_46: G = __loaded[33];
-    let __v_47: G = __loaded[34];
-    let __v_48: G = __loaded[35];
-    let __v_49: G = __loaded[36];
-    let __v_50: G = __loaded[37];
-    let __v_51: G = __loaded[38];
-    let __v_52: G = __loaded[39];
-    let __v_53: G = __loaded[40];
-    let __v_54: G = __loaded[41];
-    let __v_55: G = __loaded[42];
-    let __v_56: G = __loaded[43];
-    let __v_57: G = __loaded[44];
-    let __v_58: G = __loaded[45];
-    let __v_59: G = __loaded[46];
-    match __v_13.as_canonical_u64() {
-      1u64 => {
-        let __v_60: G = G::from_u64(1);
-        let __v_61: G = G::from_u64(1);
-        let __v_62: G = { let __values: [G; 3] = [__v_60, __v_61, __v_61]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_167] = [__v_62];
-        record.function_queries[167].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__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_1, __v_2, __v_3, __v_4, __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[165].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_165] = unsafe { *(result.output.as_ptr() as *const [G; OUT_165]) }; __ret } else { aiur_fn_165(__args, record, io_buffer, __cu)? } };
-        let __v_60: G = __r_arr[0];
-        let __v_61: G = G::from_u64(1);
-        let __v_62: G = (__v_8 + __v_61);
-        let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_59, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_62, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[167].get_mut(&__args[..]) { 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_63: G = __r_arr[0];
-        let __r_arr: [G; OUT_773] = { let __args: [G; IN_773] = [__v_60, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[773].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_773] = unsafe { *(result.output.as_ptr() as *const [G; OUT_773]) }; __ret } else { aiur_fn_773(__args, record, io_buffer, __cu)? } };
-        let __v_64: G = __r_arr[0];
-        let __ret: [G; OUT_167] = [__v_64];
-        record.function_queries[167].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_168: usize = 1;
-const IN_168: usize = 1;
-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 __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_168] = [__v_2, __v_3];
-        record.function_queries[168].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_169: usize = 7;
-const IN_169: usize = 7;
-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 __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { 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 __v_8: G = __r_arr[1];
-    let __v_9: G = __r_arr[2];
-    let __v_10: G = __r_arr[3];
-    let __v_11: G = __r_arr[4];
-    let __v_12: G = __r_arr[5];
-    let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_0, __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 !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_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 = { let __values: [G; 6] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; 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 __v_20: G = G::from_u64(1);
-    let __v_21: G = G::from_u64(1);
-    let __v_22: G = { let __values: [G; 3] = [__v_20, __v_21, __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 __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_0, __v_1, __v_2, __v_19, __v_3, __v_4, __v_5, __v_6, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { 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_23: G = __r_arr[0];
-    let __ret: [G; OUT_169] = [__v_23];
-    record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_170: usize = 9;
-const IN_170: usize = 9;
-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 __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_9: G = __loaded[0];
-    let __v_10: G = __loaded[1];
-    let __v_11: G = __loaded[2];
-    match __v_9.as_canonical_u64() {
-      1u64 => {
-        let __v_12: G = G::from_u64(1);
-        let __v_13: G = G::from_u64(1);
-        let __v_14: G = { let __values: [G; 3] = [__v_12, __v_13, __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 __ret: [G; OUT_170] = [__v_14];
-        record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __loaded: [G; 48] = { let __mq = record.memory_queries.get_mut(&48).ok_or(ExecError::InvalidMemorySize(48))?; 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: 48 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 48] = __args[..48].try_into().unwrap(); __arr };
-        let __v_12: G = __loaded[0];
-        let __v_13: G = __loaded[1];
-        let __v_14: G = __loaded[2];
-        let __v_15: G = __loaded[3];
-        let __v_16: G = __loaded[4];
-        let __v_17: G = __loaded[5];
-        let __v_18: G = __loaded[6];
-        let __v_19: G = __loaded[7];
-        let __v_20: G = __loaded[8];
-        let __v_21: G = __loaded[9];
-        let __v_22: G = __loaded[10];
-        let __v_23: G = __loaded[11];
-        let __v_24: G = __loaded[12];
-        let __v_25: G = __loaded[13];
-        let __v_26: G = __loaded[14];
-        let __v_27: G = __loaded[15];
-        let __v_28: G = __loaded[16];
-        let __v_29: G = __loaded[17];
-        let __v_30: G = __loaded[18];
-        let __v_31: G = __loaded[19];
-        let __v_32: G = __loaded[20];
-        let __v_33: G = __loaded[21];
-        let __v_34: G = __loaded[22];
-        let __v_35: G = __loaded[23];
-        let __v_36: G = __loaded[24];
-        let __v_37: G = __loaded[25];
-        let __v_38: G = __loaded[26];
-        let __v_39: G = __loaded[27];
-        let __v_40: G = __loaded[28];
-        let __v_41: G = __loaded[29];
-        let __v_42: G = __loaded[30];
-        let __v_43: G = __loaded[31];
-        let __v_44: G = __loaded[32];
-        let __v_45: G = __loaded[33];
-        let __v_46: G = __loaded[34];
-        let __v_47: G = __loaded[35];
-        let __v_48: G = __loaded[36];
-        let __v_49: G = __loaded[37];
-        let __v_50: G = __loaded[38];
-        let __v_51: G = __loaded[39];
-        let __v_52: G = __loaded[40];
-        let __v_53: G = __loaded[41];
-        let __v_54: G = __loaded[42];
-        let __v_55: G = __loaded[43];
-        let __v_56: G = __loaded[44];
-        let __v_57: G = __loaded[45];
-        let __v_58: G = __loaded[46];
-        let __v_59: G = __loaded[47];
-        let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[168].get_mut(&__args[..]) { 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_60: G = __r_arr[0];
-        let __v_61: G = __r_arr[1];
-        match __v_12.as_canonical_u64() {
-          _ => {
-            match __v_12.as_canonical_u64() {
-              8u64 => {
-                let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__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]; let __cu = unconstrained; if let Some(result) = record.function_queries[137].get_mut(&__args[..]) { 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_62: G = __r_arr[0];
-                let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_62.as_canonical_u64() {
-  0u64 => {
-    let __v_63: G = G::from_u64(0);
-    break '__mc_0 [__v_63];
-  },
-  _ => {
-    let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_62, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[136].get_mut(&__args[..]) { 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_63: G = __r_arr[0];
-    break '__mc_0 [__v_63];
-  },
-}
- };
-                let __v_63: G = __mc_out___mc_0[0];
-                match __v_63.as_canonical_u64() {
-                  1u64 => {
-                    let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_11, __v_61, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { 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_64: G = __r_arr[0];
-                    let __ret: [G; OUT_170] = [__v_64];
-                    record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
-                  0u64 => {
-                    let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_62.as_canonical_u64() {
-  0u64 => {
-    break '__mc_1 [__v_8];
-  },
-  _ => {
-    let __v_64: G = G::from_u64(0);
-    let __v_65: G = { let __values: [G; 3] = [__v_64, __v_62, __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 } };
-    break '__mc_1 [__v_65];
-  },
-}
- };
-                    let __v_64: G = __mc_out___mc_1[0];
-                    let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { 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_65: G = __r_arr[0];
-                    let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_60, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { 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_66: G = __r_arr[0];
-                    let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_60, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[151].get_mut(&__args[..]) { 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_67: G = __r_arr[0];
-                    let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__v_58, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[144].get_mut(&__args[..]) { 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_68: G = __r_arr[0];
-                    let __v_69: G = __r_arr[1];
-                    let __v_70: G = G::from_u64(0);
-                    let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_13, __v_66, __v_70]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { 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_71: G = __r_arr[0];
-                    let __v_72: G = G::from_u64(0);
-                    let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_13, __v_57, __v_68, __v_71, __v_69, __v_59, __v_13, __v_66, __v_72, __v_58, __v_2, __v_6, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[167].get_mut(&__args[..]) { 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_73: G = __r_arr[0];
-                    let __v_74: G = (__v_7 + __v_65);
-                    let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_11, __v_61, __v_2, __v_3, __v_4, __v_5, __v_6, __v_74, __v_64]; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { 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_75: G = __r_arr[0];
-                    let __r_arr: [G; OUT_773] = { let __args: [G; IN_773] = [__v_73, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[773].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_773] = unsafe { *(result.output.as_ptr() as *const [G; OUT_773]) }; __ret } else { aiur_fn_773(__args, record, io_buffer, __cu)? } };
-                    let __v_76: G = __r_arr[0];
-                    let __ret: [G; OUT_170] = [__v_76];
-                    record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
-                  _ => {
-                    return Err(ExecError::MatchNoCase(__v_63.as_canonical_u64()));
-                  },
-                }
-              },
-              6u64 => {
-                let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_11, __v_61, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { 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_62: G = __r_arr[0];
-                let __ret: [G; OUT_170] = [__v_62];
-                record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              4u64 => {
-                let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_11, __v_61, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { 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_62: G = __r_arr[0];
-                let __ret: [G; OUT_170] = [__v_62];
-                record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              5u64 => {
-                let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_11, __v_61, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { 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_62: G = __r_arr[0];
-                let __ret: [G; OUT_170] = [__v_62];
-                record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              7u64 => {
-                let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_11, __v_61, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { 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_62: G = __r_arr[0];
-                let __ret: [G; OUT_170] = [__v_62];
-                record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              0u64 => {
-                let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__v_58, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[144].get_mut(&__args[..]) { 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_62: G = __r_arr[0];
-                let __v_63: G = __r_arr[1];
-                let __v_64: G = G::from_u64(0);
-                let __v_65: G = G::from_u64(1);
-                let __v_66: G = G::from_u64(1);
-                let __v_67: G = { let __values: [G; 3] = [__v_65, __v_66, __v_66]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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; 3] = [__v_64, __v_7, __v_67]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_123] = { let __args: [G; IN_123] = [__v_60]; let __cu = true; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { 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_69: G = __r_arr[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 = { let __values: [G; 52] = [__v_57, __v_62, __v_68, __v_63, __v_59, __v_70, __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_69, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71]; let __mq = record.memory_queries.get_mut(&52).ok_or(ExecError::InvalidMemorySize(52))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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 = G::from_u64(1);
-                let __v_75: G = (__v_7 + __v_74);
-                let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_11, __v_61, __v_2, __v_3, __v_4, __v_5, __v_6, __v_75, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { 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_76: G = __r_arr[0];
-                let __v_77: G = { let __values: [G; 3] = [__v_72, __v_73, __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 __ret: [G; OUT_170] = [__v_77];
-                record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              2u64 => {
-                let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__v_58, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[144].get_mut(&__args[..]) { 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_62: G = __r_arr[0];
-                let __v_63: G = __r_arr[1];
-                let __v_64: G = G::from_u64(1);
-                let __v_65: G = G::from_u64(1);
-                let __v_66: G = { let __values: [G; 3] = [__v_64, __v_65, __v_65]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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 = G::from_u64(1);
-                let __v_68: G = G::from_u64(0);
-                let __v_69: G = G::from_u64(0);
-                let __v_70: G = { let __values: [G; 52] = [__v_57, __v_62, __v_66, __v_63, __v_59, __v_67, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68]; let __mq = record.memory_queries.get_mut(&52).ok_or(ExecError::InvalidMemorySize(52))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_71: G = G::from_u64(1);
-                let __v_72: G = (__v_7 + __v_71);
-                let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_11, __v_61, __v_2, __v_3, __v_4, __v_5, __v_6, __v_72, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { 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_73: G = __r_arr[0];
-                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 __ret: [G; OUT_170] = [__v_74];
-                record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              3u64 => {
-                let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__v_58, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[144].get_mut(&__args[..]) { 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_62: G = __r_arr[0];
-                let __v_63: G = __r_arr[1];
-                let __v_64: G = G::from_u64(1);
-                let __v_65: G = G::from_u64(1);
-                let __v_66: G = { let __values: [G; 3] = [__v_64, __v_65, __v_65]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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 = G::from_u64(2);
-                let __v_68: G = G::from_u64(0);
-                let __v_69: G = G::from_u64(0);
-                let __v_70: G = { let __values: [G; 52] = [__v_57, __v_62, __v_66, __v_63, __v_59, __v_67, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68]; let __mq = record.memory_queries.get_mut(&52).ok_or(ExecError::InvalidMemorySize(52))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_71: G = G::from_u64(1);
-                let __v_72: G = (__v_7 + __v_71);
-                let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_11, __v_61, __v_2, __v_3, __v_4, __v_5, __v_6, __v_72, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { 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_73: G = __r_arr[0];
-                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 __ret: [G; OUT_170] = [__v_74];
-                record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              1u64 => {
-                let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__v_58, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[144].get_mut(&__args[..]) { 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_62: G = __r_arr[0];
-                let __v_63: G = __r_arr[1];
-                let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__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_58, __v_57, __v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { 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_64: G = __r_arr[0];
-                let __v_65: G = __r_arr[1];
-                let __v_66: G = G::from_u64(0);
-                let __v_67: G = G::from_u64(1);
-                let __v_68: G = G::from_u64(1);
-                let __v_69: G = { let __values: [G; 3] = [__v_67, __v_68, __v_68]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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; 3] = [__v_66, __v_7, __v_69]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_71: G = G::from_u64(3);
-                let __v_72: G = G::from_u64(0);
-                let __v_73: G = { let __values: [G; 52] = [__v_57, __v_62, __v_70, __v_63, __v_59, __v_71, __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_64, __v_65]; let __mq = record.memory_queries.get_mut(&52).ok_or(ExecError::InvalidMemorySize(52))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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 = G::from_u64(1);
-                let __v_75: G = (__v_7 + __v_74);
-                let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_11, __v_61, __v_2, __v_3, __v_4, __v_5, __v_6, __v_75, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { 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_76: G = __r_arr[0];
-                let __v_77: G = { let __values: [G; 3] = [__v_72, __v_73, __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 __ret: [G; OUT_170] = [__v_77];
-                record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              _ => {
-                return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64()));
-              },
-            }
-          },
-        }
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_171: usize = 10;
-const IN_171: usize = 10;
-const OUT_171: usize = 2;
-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 = G::from_u64(0);
-    let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_0, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[774].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } else { aiur_fn_774(__args, record, io_buffer, __cu)? } };
-    let __v_11: G = __r_arr[0];
-    match __v_11.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_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 __ret: [G; OUT_171] = [__v_2, __v_3];
-            record.function_queries[171].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          0u64 => {
-            let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_13, __v_14, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[171].get_mut(&__args[..]) { 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 __v_15: G = __r_arr[0];
-            let __v_16: G = __r_arr[1];
-            let __ret: [G; OUT_171] = [__v_15, __v_16];
-            record.function_queries[171].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64()));
-          },
-        }
-      },
-      _ => {
-        let __v_12: G = G::from_u64(4);
-        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_13: G = __loaded[0];
-        let __v_14: G = __loaded[1];
-        let __v_15: G = __loaded[2];
-        let __v_16: G = __loaded[3];
-        let __v_17: G = __loaded[4];
-        let __v_18: G = __loaded[5];
-        let __v_19: G = __loaded[6];
-        let __v_20: G = __loaded[7];
-        let __v_21: G = __loaded[8];
-        let __v_22: G = __loaded[9];
-        let __v_23: G = __loaded[10];
-        let __v_24: G = __loaded[11];
-        let __v_25: G = __loaded[12];
-        let __v_26: G = __loaded[13];
-        let __v_27: G = __loaded[14];
-        let __v_28: G = __loaded[15];
-        let __v_29: G = __loaded[16];
-        let __v_30: G = __loaded[17];
-        let __v_31: G = __loaded[18];
-        let __v_32: G = __loaded[19];
-        let __v_33: G = __loaded[20];
-        let __v_34: G = __loaded[21];
-        let __v_35: G = __loaded[22];
-        let __v_36: G = __loaded[23];
-        let __v_37: G = __loaded[24];
-        let __v_38: G = __loaded[25];
-        let __v_39: G = __loaded[26];
-        let __v_40: G = __loaded[27];
-        let __v_41: G = __loaded[28];
-        let __v_42: G = __loaded[29];
-        let __v_43: G = __loaded[30];
-        let __v_44: G = __loaded[31];
-        let __io_pair: (G, G) = { let __key: [G; 32] = [__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]; let __info = io_buffer.get_info(__v_12, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) };
-        let __v_45: G = __io_pair.0;
-        let __v_46: G = __io_pair.1;
-        let __v_47: G = G::from_u64(4);
-        let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_47, __v_45, __v_46]; let __cu = true; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { let __ret: [G; OUT_0] = unsafe { *(result.output.as_ptr() as *const [G; OUT_0]) }; __ret } else { aiur_fn_0(__args, record, io_buffer, __cu)? } };
-        let __v_48: 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_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];
-        let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_49.as_canonical_u64() {
-  0u64 => {
-    break '__mc_0 [__v_50];
-  },
-  _ => {
-    return Err(ExecError::MatchNoCase(__v_49.as_canonical_u64()));
-  },
-}
- };
-        let __v_52: G = __mc_out___mc_0[0];
-        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_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_53: G = __loaded[0];
-            let __v_54: G = __loaded[1];
-            let __v_55: G = __loaded[2];
-            match __v_53.as_canonical_u64() {
-              1u64 => {
-                let __ret: [G; OUT_171] = [__v_2, __v_3];
-                record.function_queries[171].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              0u64 => {
-                let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_54, __v_55, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[171].get_mut(&__args[..]) { 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 __v_56: G = __r_arr[0];
-                let __v_57: G = __r_arr[1];
-                let __ret: [G; OUT_171] = [__v_56, __v_57];
-                record.function_queries[171].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              _ => {
-                return Err(ExecError::MatchNoCase(__v_53.as_canonical_u64()));
-              },
-            }
-          },
-          _ => {
-            let __v_53: G = G::from_u64(0);
-            let __v_54: G = { let __values: [G; 3] = [__v_53, __v_0, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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 = G::from_u64(1);
-            let __r_arr: [G; OUT_785] = { let __args: [G; IN_785] = [__v_0, __v_55, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[785].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_785] = unsafe { *(result.output.as_ptr() as *const [G; OUT_785]) }; __ret } else { aiur_fn_785(__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 __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { 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_62: G = __r_arr[0];
-            let __v_63: G = __r_arr[1];
-            let __v_64: G = __r_arr[2];
-            let __v_65: G = __r_arr[3];
-            let __v_66: G = __r_arr[4];
-            let __v_67: G = __r_arr[5];
-            let __v_68: G = __r_arr[6];
-            let __v_69: G = __r_arr[7];
-            let __v_70: G = __r_arr[8];
-            let __v_71: G = __r_arr[9];
-            let __v_72: G = __r_arr[10];
-            let __v_73: G = __r_arr[11];
-            let __v_74: G = __r_arr[12];
-            let __v_75: G = __r_arr[13];
-            let __v_76: G = __r_arr[14];
-            let __v_77: G = __r_arr[15];
-            let __v_78: G = __r_arr[16];
-            let __v_79: G = __r_arr[17];
-            let __v_80: G = __r_arr[18];
-            let __v_81: G = __r_arr[19];
-            let __v_82: G = __r_arr[20];
-            let __v_83: G = __r_arr[21];
-            let __v_84: G = __r_arr[22];
-            let __v_85: G = __r_arr[23];
-            let __v_86: G = __r_arr[24];
-            let __v_87: G = __r_arr[25];
-            let __v_88: G = __r_arr[26];
-            let __v_89: G = __r_arr[27];
-            let __v_90: G = __r_arr[28];
-            let __v_91: G = __r_arr[29];
-            let __v_92: G = __r_arr[30];
-            let __v_93: G = __r_arr[31];
-            let __v_94: G = __r_arr[32];
-            let __v_95: G = __r_arr[33];
-            let __v_96: G = __r_arr[34];
-            let __v_97: G = __r_arr[35];
-            let __v_98: G = __r_arr[36];
-            let __v_99: G = __r_arr[37];
-            let __v_100: G = __r_arr[38];
-            let __v_101: G = __r_arr[39];
-            let __v_102: G = __r_arr[40];
-            let __v_103: G = __r_arr[41];
-            let __v_104: G = __r_arr[42];
-            let __v_105: G = __r_arr[43];
-            let __v_106: G = __r_arr[44];
-            let __v_107: G = __r_arr[45];
-            let __v_108: G = __r_arr[46];
-            let __v_109: G = __r_arr[47];
-            let __v_110: G = G::from_u64(0);
-            let __v_111: G = { let __values: [G; 48] = [__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]; let __mq = record.memory_queries.get_mut(&48).ok_or(ExecError::InvalidMemorySize(48))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __v_112: G = { let __values: [G; 3] = [__v_110, __v_111, __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 } };
-            match __v_62.as_canonical_u64() {
-              _ => {
-                let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__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]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { 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_113: G = __r_arr[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 __v_121: G = G::from_u64(0);
-                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 __v_129: G = G::from_u64(0);
-                let __v_130: G = G::from_u64(0);
-                let __v_131: G = G::from_u64(0);
-                let __v_132: G = G::from_u64(0);
-                let __v_133: G = G::from_u64(0);
-                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 __v_137: G = G::from_u64(0);
-                let __v_138: G = G::from_u64(0);
-                let __v_139: G = G::from_u64(0);
-                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 = { let __values: [G; 32] = [__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, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145]; 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_122] = { let __args: [G; IN_122] = [__v_113, __v_146]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_147: G = __r_arr[0];
-                match __v_147.as_canonical_u64() {
-                  1u64 => {
-                    let __v_148: G = G::from_u64(1);
-                    let __v_149: G = G::from_u64(1);
-                    let __v_150: G = { let __values: [G; 3] = [__v_148, __v_149, __v_149]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_773] = { let __args: [G; IN_773] = [__v_108, __v_150]; let __cu = unconstrained; if let Some(result) = record.function_queries[773].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_773] = unsafe { *(result.output.as_ptr() as *const [G; OUT_773]) }; __ret } else { aiur_fn_773(__args, record, io_buffer, __cu)? } };
-                    let __v_151: G = __r_arr[0];
-                    let __r_arr: [G; OUT_773] = { let __args: [G; IN_773] = [__v_151, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[773].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_773] = unsafe { *(result.output.as_ptr() as *const [G; OUT_773]) }; __ret } else { aiur_fn_773(__args, record, io_buffer, __cu)? } };
-                    let __v_152: 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_152.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).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_153: G = __loaded[0];
-                    let __v_154: G = __loaded[1];
-                    let __v_155: G = __loaded[2];
-                    match __v_153.as_canonical_u64() {
-                      1u64 => {
-                        let __ret: [G; OUT_171] = [__v_54, __v_112];
-                        record.function_queries[171].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                        return Ok(__ret);
-                      },
-                      0u64 => {
-                        let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_154, __v_155, __v_54, __v_112, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[171].get_mut(&__args[..]) { 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 __v_156: G = __r_arr[0];
-                        let __v_157: G = __r_arr[1];
-                        let __ret: [G; OUT_171] = [__v_156, __v_157];
-                        record.function_queries[171].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                        return Ok(__ret);
-                      },
-                      _ => {
-                        return Err(ExecError::MatchNoCase(__v_153.as_canonical_u64()));
-                      },
-                    }
-                  },
-                  0u64 => {
-                    let __v_148: G = G::from_u64(0);
-                    let __v_149: G = G::from_u64(1);
-                    let __v_150: G = G::from_u64(1);
-                    let __v_151: G = { let __values: [G; 3] = [__v_149, __v_150, __v_150]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __v_152: G = { let __values: [G; 3] = [__v_148, __v_113, __v_151]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_773] = { let __args: [G; IN_773] = [__v_108, __v_152]; let __cu = unconstrained; if let Some(result) = record.function_queries[773].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_773] = unsafe { *(result.output.as_ptr() as *const [G; OUT_773]) }; __ret } else { aiur_fn_773(__args, record, io_buffer, __cu)? } };
-                    let __v_153: G = __r_arr[0];
-                    let __r_arr: [G; OUT_773] = { let __args: [G; IN_773] = [__v_153, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[773].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_773] = unsafe { *(result.output.as_ptr() as *const [G; OUT_773]) }; __ret } else { aiur_fn_773(__args, record, io_buffer, __cu)? } };
-                    let __v_154: 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_154.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).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_155: G = __loaded[0];
-                    let __v_156: G = __loaded[1];
-                    let __v_157: G = __loaded[2];
-                    match __v_155.as_canonical_u64() {
-                      1u64 => {
-                        let __ret: [G; OUT_171] = [__v_54, __v_112];
-                        record.function_queries[171].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                        return Ok(__ret);
-                      },
-                      0u64 => {
-                        let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_156, __v_157, __v_54, __v_112, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[171].get_mut(&__args[..]) { 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 __v_158: G = __r_arr[0];
-                        let __v_159: G = __r_arr[1];
-                        let __ret: [G; OUT_171] = [__v_158, __v_159];
-                        record.function_queries[171].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                        return Ok(__ret);
-                      },
-                      _ => {
-                        return Err(ExecError::MatchNoCase(__v_155.as_canonical_u64()));
-                      },
-                    }
-                  },
-                  _ => {
-                    return Err(ExecError::MatchNoCase(__v_147.as_canonical_u64()));
-                  },
-                }
-              },
-            }
-          },
-        }
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_172: usize = 1;
-const IN_172: usize = 1;
-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 __loaded: [G; 48] = { let __mq = record.memory_queries.get_mut(&48).ok_or(ExecError::InvalidMemorySize(48))?; 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: 48 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 48] = __args[..48].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 __v_35: G = __loaded[34];
-    let __v_36: G = __loaded[35];
-    let __v_37: G = __loaded[36];
-    let __v_38: G = __loaded[37];
-    let __v_39: G = __loaded[38];
-    let __v_40: G = __loaded[39];
-    let __v_41: G = __loaded[40];
-    let __v_42: G = __loaded[41];
-    let __v_43: G = __loaded[42];
-    let __v_44: G = __loaded[43];
-    let __v_45: G = __loaded[44];
-    let __v_46: G = __loaded[45];
-    let __v_47: G = __loaded[46];
-    let __v_48: G = __loaded[47];
-    match __v_1.as_canonical_u64() {
-      _ => {
-        match __v_1.as_canonical_u64() {
-          6u64 => {
-            let __v_49: G = G::from_u64(1);
-            let __ret: [G; OUT_172] = [__v_49];
-            record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          4u64 => {
-            let __v_49: G = G::from_u64(1);
-            let __ret: [G; OUT_172] = [__v_49];
-            record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          5u64 => {
-            let __v_49: G = G::from_u64(1);
-            let __ret: [G; OUT_172] = [__v_49];
-            record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          7u64 => {
-            let __v_49: G = G::from_u64(1);
-            let __ret: [G; OUT_172] = [__v_49];
-            record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            let __v_49: G = G::from_u64(0);
-            let __ret: [G; OUT_172] = [__v_49];
-            record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-        }
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_173: usize = 10;
-const IN_173: usize = 10;
-const OUT_173: usize = 6;
-fn aiur_fn_173(
-  inp: [G; IN_173],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> 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 __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 __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_10: G = __loaded[0];
-    let __v_11: G = __loaded[1];
-    let __v_12: G = __loaded[2];
-    match __v_10.as_canonical_u64() {
-      1u64 => {
-        let __ret: [G; OUT_173] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9];
-        record.function_queries[173].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_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_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_16: G = __loaded[0];
-            let __v_17: G = __loaded[1];
-            let __v_18: G = __loaded[2];
-            match __v_16.as_canonical_u64() {
-              0u64 => {
-                let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[172].get_mut(&__args[..]) { 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 __v_19: G = __r_arr[0];
-                let __v_20: G = (__v_19 - __v_3);
-                match __v_20.as_canonical_u64() {
-                  0u64 => {
-                    let __r_arr: [G; OUT_785] = { let __args: [G; IN_785] = [__v_17, __v_11, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[785].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_785] = unsafe { *(result.output.as_ptr() as *const [G; OUT_785]) }; __ret } else { aiur_fn_785(__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 __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__v_12, __v_15, __v_18, __v_3, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[173].get_mut(&__args[..]) { 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_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 __ret: [G; OUT_173] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32];
-                    record.function_queries[173].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
-                  _ => {
-                    let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__v_12, __v_15, __v_18, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[173].get_mut(&__args[..]) { 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_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 __ret: [G; OUT_173] = [__v_21, __v_22, __v_23, __v_24, __v_25, __v_26];
-                    record.function_queries[173].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
-                }
-              },
-              _ => {
-                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()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_174: usize = 3;
-const IN_174: usize = 3;
-const OUT_174: usize = 6;
-fn aiur_fn_174(
-  inp: [G; IN_174],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_174], 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 = G::from_u64(0);
-    let __v_4: G = G::from_u64(1);
-    let __v_5: G = G::from_u64(1);
-    let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_5, __v_5, __v_5, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[173].get_mut(&__args[..]) { 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_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 = G::from_u64(1);
-    let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__v_0, __v_1, __v_2, __v_12, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[173].get_mut(&__args[..]) { 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_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 __ret: [G; OUT_174] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18];
-    record.function_queries[174].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_175: usize = 7;
-const IN_175: usize = 7;
-const OUT_175: usize = 6;
-fn aiur_fn_175(
-  inp: [G; IN_175],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> 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 __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; 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_7: G = __loaded[0];
-    let __v_8: G = __loaded[1];
-    let __v_9: G = __loaded[2];
-    let __v_10: G = __loaded[3];
-    match __v_7.as_canonical_u64() {
-      1u64 => {
-        let __ret: [G; OUT_175] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6];
-        record.function_queries[175].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __r_arr: [G; OUT_785] = { let __args: [G; IN_785] = [__v_8, __v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[785].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_785] = unsafe { *(result.output.as_ptr() as *const [G; OUT_785]) }; __ret } else { aiur_fn_785(__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 __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[175].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_175] = unsafe { *(result.output.as_ptr() as *const [G; OUT_175]) }; __ret } else { aiur_fn_175(__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 __ret: [G; OUT_175] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22];
-        record.function_queries[175].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_176: usize = 9;
-const IN_176: usize = 9;
-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_176], 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 = (__v_1 - __v_0);
-    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_176] = [__v_12];
-        record.function_queries[176].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_0, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[774].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } else { aiur_fn_774(__args, record, io_buffer, __cu)? } };
-        let __v_10: G = __r_arr[0];
-        let __v_11: G = G::from_u64(0);
-        let __v_12: G = G::from_u64(1);
-        let __v_13: G = (__v_0 + __v_12);
-        let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_13, __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[176].get_mut(&__args[..]) { 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_14: G = __r_arr[0];
-        let __v_15: G = { let __values: [G; 3] = [__v_11, __v_10, __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_176] = [__v_15];
-        record.function_queries[176].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_177: usize = 3;
-const IN_177: usize = 3;
-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_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 __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; 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_177] = [__v_8];
-        record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __loaded: [G; 48] = { let __mq = record.memory_queries.get_mut(&48).ok_or(ExecError::InvalidMemorySize(48))?; 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: 48 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 48] = __args[..48].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];
-        let __v_13: G = __loaded[7];
-        let __v_14: G = __loaded[8];
-        let __v_15: G = __loaded[9];
-        let __v_16: G = __loaded[10];
-        let __v_17: G = __loaded[11];
-        let __v_18: G = __loaded[12];
-        let __v_19: G = __loaded[13];
-        let __v_20: G = __loaded[14];
-        let __v_21: G = __loaded[15];
-        let __v_22: G = __loaded[16];
-        let __v_23: G = __loaded[17];
-        let __v_24: G = __loaded[18];
-        let __v_25: G = __loaded[19];
-        let __v_26: G = __loaded[20];
-        let __v_27: G = __loaded[21];
-        let __v_28: G = __loaded[22];
-        let __v_29: G = __loaded[23];
-        let __v_30: G = __loaded[24];
-        let __v_31: G = __loaded[25];
-        let __v_32: G = __loaded[26];
-        let __v_33: G = __loaded[27];
-        let __v_34: G = __loaded[28];
-        let __v_35: G = __loaded[29];
-        let __v_36: G = __loaded[30];
-        let __v_37: G = __loaded[31];
-        let __v_38: G = __loaded[32];
-        let __v_39: G = __loaded[33];
-        let __v_40: G = __loaded[34];
-        let __v_41: G = __loaded[35];
-        let __v_42: G = __loaded[36];
-        let __v_43: G = __loaded[37];
-        let __v_44: G = __loaded[38];
-        let __v_45: G = __loaded[39];
-        let __v_46: G = __loaded[40];
-        let __v_47: G = __loaded[41];
-        let __v_48: G = __loaded[42];
-        let __v_49: G = __loaded[43];
-        let __v_50: G = __loaded[44];
-        let __v_51: G = __loaded[45];
-        let __v_52: G = __loaded[46];
-        let __v_53: G = __loaded[47];
-        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_54: G = __loaded[0];
-        let __v_55: G = __loaded[1];
-        let __v_56: G = __loaded[2];
-        match __v_54.as_canonical_u64() {
-          0u64 => {
-            match __v_6.as_canonical_u64() {
-              _ => {
-                match __v_6.as_canonical_u64() {
-                  6u64 => {
-                    match __v_7.as_canonical_u64() {
-                      _ => {
-                        let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_15, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[135].get_mut(&__args[..]) { 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_57: G = __r_arr[0];
-                        let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { 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_58: G = __r_arr[0];
-                        let __v_59: G = __r_arr[1];
-                        let __v_60: G = __r_arr[2];
-                        let __v_61: G = __r_arr[3];
-                        let __v_62: G = __r_arr[4];
-                        let __v_63: G = __r_arr[5];
-                        let __v_64: G = __r_arr[6];
-                        let __v_65: G = __r_arr[7];
-                        let __v_66: G = __r_arr[8];
-                        let __v_67: G = __r_arr[9];
-                        let __v_68: G = __r_arr[10];
-                        let __v_69: G = __r_arr[11];
-                        let __v_70: G = __r_arr[12];
-                        let __v_71: G = __r_arr[13];
-                        let __v_72: G = __r_arr[14];
-                        let __v_73: G = __r_arr[15];
-                        let __v_74: G = __r_arr[16];
-                        let __v_75: G = __r_arr[17];
-                        let __v_76: G = __r_arr[18];
-                        let __v_77: G = __r_arr[19];
-                        let __v_78: G = __r_arr[20];
-                        let __v_79: G = __r_arr[21];
-                        let __v_80: G = __r_arr[22];
-                        let __v_81: G = __r_arr[23];
-                        let __v_82: G = __r_arr[24];
-                        let __v_83: G = __r_arr[25];
-                        let __v_84: G = __r_arr[26];
-                        let __v_85: G = __r_arr[27];
-                        let __v_86: G = __r_arr[28];
-                        let __v_87: G = __r_arr[29];
-                        let __v_88: G = __r_arr[30];
-                        let __v_89: G = __r_arr[31];
-                        let __v_90: G = __r_arr[32];
-                        let __v_91: G = __r_arr[33];
-                        let __v_92: G = __r_arr[34];
-                        let __v_93: G = __r_arr[35];
-                        let __v_94: G = __r_arr[36];
-                        let __v_95: G = __r_arr[37];
-                        let __v_96: G = __r_arr[38];
-                        let __v_97: G = __r_arr[39];
-                        let __v_98: G = __r_arr[40];
-                        let __v_99: G = __r_arr[41];
-                        let __v_100: G = __r_arr[42];
-                        let __v_101: G = __r_arr[43];
-                        let __v_102: G = __r_arr[44];
-                        let __v_103: G = __r_arr[45];
-                        let __v_104: G = __r_arr[46];
-                        let __v_105: G = __r_arr[47];
-                        match __v_58.as_canonical_u64() {
-                          _ => {
-                            match __v_58.as_canonical_u64() {
-                              8u64 => {
-                                let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__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[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } };
-                                let __v_106: G = __r_arr[0];
-                                let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_59, __v_106]; let __cu = unconstrained; if let Some(result) = record.function_queries[128].get_mut(&__args[..]) { 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_107: G = __r_arr[0];
-                                let __v_108: G = G::from_u64(1);
-                                let __v_109: G = (__v_107 + __v_108);
-                                let __v_110: G = (__v_57 + __v_109);
-                                let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__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[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } };
-                                let __v_111: G = __r_arr[0];
-                                let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = [__v_59, __v_111]; let __cu = unconstrained; if let Some(result) = record.function_queries[178].get_mut(&__args[..]) { 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 __v_112: G = __r_arr[0];
-                                let __v_113: G = G::from_u64(0);
-                                let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_110, __v_112, __v_113]; let __cu = unconstrained; if let Some(result) = record.function_queries[180].get_mut(&__args[..]) { 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_114: G = __r_arr[0];
-                                let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_5, __v_56, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[177].get_mut(&__args[..]) { 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_115: G = __r_arr[0];
-                                let __r_arr: [G; OUT_787] = { let __args: [G; IN_787] = [__v_114, __v_115]; let __cu = unconstrained; if let Some(result) = record.function_queries[787].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_787] = unsafe { *(result.output.as_ptr() as *const [G; OUT_787]) }; __ret } else { aiur_fn_787(__args, record, io_buffer, __cu)? } };
-                                let __v_116: G = __r_arr[0];
-                                let __ret: [G; OUT_177] = [__v_116];
-                                record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                return Ok(__ret);
-                              },
-                              _ => {
-                                let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_5, __v_56, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[177].get_mut(&__args[..]) { 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_106: G = __r_arr[0];
-                                let __ret: [G; OUT_177] = [__v_106];
-                                record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                return Ok(__ret);
-                              },
-                            }
-                          },
-                        }
-                      },
-                    }
-                  },
-                  _ => {
-                    let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_5, __v_56, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[177].get_mut(&__args[..]) { 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_57: G = __r_arr[0];
-                    let __ret: [G; OUT_177] = [__v_57];
-                    record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
-                }
-              },
-            }
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_54.as_canonical_u64()));
-          },
-        }
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_178: usize = 2;
-const IN_178: usize = 2;
-const OUT_178: usize = 1;
-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 = G::from_u64(0);
-    let __r_arr: [G; OUT_179] = { let __args: [G; IN_179] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[179].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_179] = unsafe { *(result.output.as_ptr() as *const [G; OUT_179]) }; __ret } else { aiur_fn_179(__args, record, io_buffer, __cu)? } };
-    let __v_3: G = __r_arr[0];
-    let __ret: [G; OUT_178] = [__v_3];
-    record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_179: usize = 3;
-const IN_179: usize = 3;
-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_179], 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; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; 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: 47 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr };
-    let __v_3: G = __loaded[0];
-    let __v_4: G = __loaded[1];
-    let __v_5: G = __loaded[2];
-    let __v_6: G = __loaded[3];
-    let __v_7: G = __loaded[4];
-    let __v_8: G = __loaded[5];
-    let __v_9: G = __loaded[6];
-    let __v_10: G = __loaded[7];
-    let __v_11: G = __loaded[8];
-    let __v_12: G = __loaded[9];
-    let __v_13: G = __loaded[10];
-    let __v_14: G = __loaded[11];
-    let __v_15: G = __loaded[12];
-    let __v_16: G = __loaded[13];
-    let __v_17: G = __loaded[14];
-    let __v_18: G = __loaded[15];
-    let __v_19: G = __loaded[16];
-    let __v_20: G = __loaded[17];
-    let __v_21: G = __loaded[18];
-    let __v_22: G = __loaded[19];
-    let __v_23: G = __loaded[20];
-    let __v_24: G = __loaded[21];
-    let __v_25: G = __loaded[22];
-    let __v_26: G = __loaded[23];
-    let __v_27: G = __loaded[24];
-    let __v_28: G = __loaded[25];
-    let __v_29: G = __loaded[26];
-    let __v_30: G = __loaded[27];
-    let __v_31: G = __loaded[28];
-    let __v_32: G = __loaded[29];
-    let __v_33: G = __loaded[30];
-    let __v_34: G = __loaded[31];
-    let __v_35: G = __loaded[32];
-    let __v_36: G = __loaded[33];
-    let __v_37: G = __loaded[34];
-    let __v_38: G = __loaded[35];
-    let __v_39: G = __loaded[36];
-    let __v_40: G = __loaded[37];
-    let __v_41: G = __loaded[38];
-    let __v_42: G = __loaded[39];
-    let __v_43: G = __loaded[40];
-    let __v_44: G = __loaded[41];
-    let __v_45: G = __loaded[42];
-    let __v_46: G = __loaded[43];
-    let __v_47: G = __loaded[44];
-    let __v_48: G = __loaded[45];
-    let __v_49: G = __loaded[46];
-    match __v_3.as_canonical_u64() {
-      1u64 => {
-        let __v_50: G = G::from_u64(0);
-        let __ret: [G; OUT_179] = [__v_50];
-        record.function_queries[179].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __v_50: G = (__v_2 - __v_1);
-        match __v_50.as_canonical_u64() {
-          0u64 => {
-            match __v_4.as_canonical_u64() {
-              1u64 => {
-                match __v_5.as_canonical_u64() {
-                  _ => {
-                    let __r_arr: [G; OUT_793] = { let __args: [G; IN_793] = [__v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[793].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_793] = unsafe { *(result.output.as_ptr() as *const [G; OUT_793]) }; __ret } else { aiur_fn_793(__args, record, io_buffer, __cu)? } };
-                    let __v_51: G = __r_arr[0];
-                    let __ret: [G; OUT_179] = [__v_51];
-                    record.function_queries[179].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
-                }
-              },
-              _ => {
-                let __v_51: G = G::from_u64(0);
-                let __ret: [G; OUT_179] = [__v_51];
-                record.function_queries[179].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-            }
-          },
-          _ => {
-            let __v_51: G = G::from_u64(1);
-            let __v_52: G = (__v_2 + __v_51);
-            let __r_arr: [G; OUT_179] = { let __args: [G; IN_179] = [__v_49, __v_1, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[179].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_179] = unsafe { *(result.output.as_ptr() as *const [G; OUT_179]) }; __ret } else { aiur_fn_179(__args, record, io_buffer, __cu)? } };
-            let __v_53: G = __r_arr[0];
-            let __ret: [G; OUT_179] = [__v_53];
-            record.function_queries[179].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-        }
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_180: usize = 12;
-const IN_180: usize = 12;
-const OUT_180: usize = 1;
-fn aiur_fn_180(
-  inp: [G; IN_180],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> 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];
-    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 = (__v_10 - __v_11);
-    match __v_12.as_canonical_u64() {
-      0u64 => {
-        let __v_13: G = G::from_u64(1);
-        let __v_14: G = G::from_u64(1);
-        let __v_15: G = { let __values: [G; 4] = [__v_13, __v_14, __v_14, __v_14]; 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_180] = [__v_15];
-        record.function_queries[180].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        let __r_arr: [G; OUT_181] = { let __args: [G; IN_181] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_11, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[181].get_mut(&__args[..]) { 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_13: G = __r_arr[0];
-        let __v_14: G = G::from_u64(0);
-        let __v_15: G = (__v_9 + __v_11);
-        let __v_16: G = G::from_u64(1);
-        let __v_17: G = (__v_11 + __v_16);
-        let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[180].get_mut(&__args[..]) { 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_18: G = __r_arr[0];
-        let __v_19: G = { let __values: [G; 4] = [__v_14, __v_15, __v_13, __v_18]; 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_180] = [__v_19];
-        record.function_queries[180].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_181: usize = 10;
-const IN_181: usize = 10;
-const OUT_181: usize = 1;
-fn aiur_fn_181(
-  inp: [G; IN_181],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> 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];
-    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 = 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 = G::from_u64(4);
-    let __v_18: G = G::from_u64(0);
-    let __v_19: G = G::from_u64(1);
-    let __v_20: G = G::from_u64(1);
-    let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __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 = G::from_u64(1);
-    let __v_23: G = G::from_u64(1);
-    let __v_24: G = { let __values: [G; 3] = [__v_22, __v_23, __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 __v_25: G = G::from_u64(1);
-    let __v_26: G = G::from_u64(1);
-    let __v_27: G = { let __values: [G; 3] = [__v_25, __v_26, __v_26]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_28: G = G::from_u64(1);
-    let __v_29: G = G::from_u64(1);
-    let __v_30: G = { let __values: [G; 3] = [__v_28, __v_29, __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 __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_17, __v_0, __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_9, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_21, __v_24, __v_27, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[65].get_mut(&__args[..]) { 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_31: G = __r_arr[0];
-    let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } else { aiur_fn_16(__args, record, io_buffer, __cu)? } };
-    let __v_32: G = __r_arr[0];
-    let __ret: [G; OUT_181] = [__v_32];
-    record.function_queries[181].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_182: usize = 1;
-const IN_182: usize = 1;
-const OUT_182: usize = 2;
-fn aiur_fn_182(
-  inp: [G; IN_182],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_182], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = G::from_u64(1);
-    let __v_2: G = G::from_u64(1);
-    let __v_3: G = { let __values: [G; 3] = [__v_1, __v_2, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    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 __v_7: G = G::from_u64(1);
-    let __v_8: G = G::from_u64(1);
-    let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __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_10: G = G::from_u64(1);
-    let __v_11: G = G::from_u64(1);
-    let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_0, __v_3, __v_6, __v_9, __v_10, __v_11, __v_11, __v_11, __v_11, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[171].get_mut(&__args[..]) { 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 __v_12: G = __r_arr[0];
-    let __v_13: G = __r_arr[1];
-    let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = [__v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[184].get_mut(&__args[..]) { 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_14: G = __r_arr[0];
-    let __v_15: G = __r_arr[1];
-    let __ret: [G; OUT_182] = [__v_14, __v_15];
-    record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_183: usize = 1;
-const IN_183: usize = 1;
-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_183], 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 __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[185].get_mut(&__args[..]) { 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_4: G = __r_arr[0];
-        let __v_5: G = __r_arr[1];
-        let __ret: [G; OUT_183] = [__v_4, __v_5];
-        record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      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 __v_7: G = G::from_u64(1);
-        let __v_8: G = G::from_u64(1);
-        let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __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_10: G = G::from_u64(1);
-        let __v_11: G = G::from_u64(1);
-        let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_2, __v_3, __v_6, __v_9, __v_10, __v_11, __v_11, __v_11, __v_11, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[171].get_mut(&__args[..]) { 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 __v_12: G = __r_arr[0];
-        let __v_13: G = __r_arr[1];
-        let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = [__v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[184].get_mut(&__args[..]) { 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_14: G = __r_arr[0];
-        let __v_15: G = __r_arr[1];
-        let __ret: [G; OUT_183] = [__v_14, __v_15];
-        record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_184: usize = 2;
-const IN_184: usize = 2;
-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_184], 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(0);
-    let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[140].get_mut(&__args[..]) { 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_3: G = __r_arr[0];
-    let __v_4: G = __r_arr[1];
-    let __v_5: G = __r_arr[2];
-    let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { 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_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 = { let __values: [G; 6] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; 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 __v_13: G = G::from_u64(0);
-    let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_1, __v_0, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[142].get_mut(&__args[..]) { 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_14: G = __r_arr[0];
-    let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_1, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { 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_15: G = __r_arr[0];
-    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 !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_16: G = __r_arr[0];
-    let __v_17: G = __r_arr[1];
-    let __v_18: G = __r_arr[2];
-    let __v_19: G = __r_arr[3];
-    let __v_20: G = __r_arr[4];
-    let __v_21: G = __r_arr[5];
-    let __v_22: G = { let __values: [G; 6] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; 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 __v_23: G = G::from_u64(0);
-    let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = [__v_1, __v_0, __v_0, __v_15, __v_22, __v_12, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[169].get_mut(&__args[..]) { 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_24: G = __r_arr[0];
-    let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { 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_25: G = __r_arr[0];
-    let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_0, __v_1, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[174].get_mut(&__args[..]) { 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_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 __v_30: G = __r_arr[4];
-    let __v_31: G = __r_arr[5];
-    let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_1, __v_0, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[177].get_mut(&__args[..]) { 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_32: G = __r_arr[0];
-    let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = [__v_32, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[175].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_175] = unsafe { *(result.output.as_ptr() as *const [G; OUT_175]) }; __ret } else { aiur_fn_175(__args, record, io_buffer, __cu)? } };
-    let __v_33: G = __r_arr[0];
-    let __v_34: G = __r_arr[1];
-    let __v_35: G = __r_arr[2];
-    let __v_36: G = __r_arr[3];
-    let __v_37: G = __r_arr[4];
-    let __v_38: G = __r_arr[5];
-    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 = G::from_u64(0);
-    let __v_49: G = G::from_u64(0);
-    let __v_50: G = G::from_u64(0);
-    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 = { let __values: [G; 32] = [__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]; 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_72: G = G::from_u64(0);
-    let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_72, __v_5, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_71]; let __cu = unconstrained; if let Some(result) = record.function_queries[176].get_mut(&__args[..]) { 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_73: G = __r_arr[0];
-    let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[185].get_mut(&__args[..]) { 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_74: G = __r_arr[0];
-    let __v_75: G = __r_arr[1];
-    let __r_arr: [G; OUT_773] = { let __args: [G; IN_773] = [__v_25, __v_74]; let __cu = unconstrained; if let Some(result) = record.function_queries[773].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_773] = unsafe { *(result.output.as_ptr() as *const [G; OUT_773]) }; __ret } else { aiur_fn_773(__args, record, io_buffer, __cu)? } };
-    let __v_76: G = __r_arr[0];
-    let __r_arr: [G; OUT_773] = { let __args: [G; IN_773] = [__v_73, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[773].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_773] = unsafe { *(result.output.as_ptr() as *const [G; OUT_773]) }; __ret } else { aiur_fn_773(__args, record, io_buffer, __cu)? } };
-    let __v_77: G = __r_arr[0];
-    let __ret: [G; OUT_184] = [__v_76, __v_77];
-    record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_185: usize = 0;
-const IN_185: usize = 0;
-const OUT_185: usize = 2;
-fn aiur_fn_185(
-  inp: [G; IN_185],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_185], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[186].get_mut(&__args[..]) { 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_0: G = __r_arr[0];
-    let __v_1: G = G::from_u64(1);
-    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_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 __v_5: G = G::from_u64(0);
-    let __v_6: G = { let __values: [G; 4] = [__v_1, __v_4, __v_5, __v_5]; 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_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 = { let __values: [G; 11] = [__v_7, __v_8, __v_6, __v_9, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_187] = { let __args: [G; IN_187] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { 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_12: G = __r_arr[0];
-    let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = [__v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[188].get_mut(&__args[..]) { 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 __v_13: G = __r_arr[0];
-    let __ret: [G; OUT_185] = [__v_13, __v_0];
-    record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_186: usize = 0;
-const IN_186: usize = 0;
-const OUT_186: usize = 1;
-fn aiur_fn_186(
-  inp: [G; IN_186],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_186], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(0);
-    let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } };
-    let __v_1: G = __r_arr[0];
-    let __v_2: G = G::from_u64(0);
-    let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[234].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_234] = unsafe { *(result.output.as_ptr() as *const [G; OUT_234]) }; __ret } else { aiur_fn_234(__args, record, io_buffer, __cu)? } };
-    let __v_3: G = __r_arr[0];
-    let __v_4: G = G::from_u64(0);
-    let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[235].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_235] = unsafe { *(result.output.as_ptr() as *const [G; OUT_235]) }; __ret } else { aiur_fn_235(__args, record, io_buffer, __cu)? } };
-    let __v_5: G = __r_arr[0];
-    let __v_6: G = G::from_u64(0);
-    let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[236].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_236] = unsafe { *(result.output.as_ptr() as *const [G; OUT_236]) }; __ret } else { aiur_fn_236(__args, record, io_buffer, __cu)? } };
-    let __v_7: G = __r_arr[0];
-    let __v_8: G = G::from_u64(0);
-    let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[237].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_237] = unsafe { *(result.output.as_ptr() as *const [G; OUT_237]) }; __ret } else { aiur_fn_237(__args, record, io_buffer, __cu)? } };
-    let __v_9: G = __r_arr[0];
-    let __v_10: G = G::from_u64(0);
-    let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[238].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_238] = unsafe { *(result.output.as_ptr() as *const [G; OUT_238]) }; __ret } else { aiur_fn_238(__args, record, io_buffer, __cu)? } };
-    let __v_11: G = __r_arr[0];
-    let __v_12: G = G::from_u64(0);
-    let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } else { aiur_fn_239(__args, record, io_buffer, __cu)? } };
-    let __v_13: G = __r_arr[0];
-    let __v_14: G = G::from_u64(0);
-    let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[240].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_240] = unsafe { *(result.output.as_ptr() as *const [G; OUT_240]) }; __ret } else { aiur_fn_240(__args, record, io_buffer, __cu)? } };
-    let __v_15: G = __r_arr[0];
-    let __v_16: G = G::from_u64(0);
-    let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } else { aiur_fn_241(__args, record, io_buffer, __cu)? } };
-    let __v_17: G = __r_arr[0];
-    let __v_18: G = G::from_u64(0);
-    let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } else { aiur_fn_242(__args, record, io_buffer, __cu)? } };
-    let __v_19: G = __r_arr[0];
-    let __v_20: G = G::from_u64(0);
-    let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } else { aiur_fn_243(__args, record, io_buffer, __cu)? } };
-    let __v_21: G = __r_arr[0];
-    let __v_22: G = G::from_u64(0);
-    let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } else { aiur_fn_244(__args, record, io_buffer, __cu)? } };
-    let __v_23: G = __r_arr[0];
-    let __v_24: G = G::from_u64(0);
-    let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } else { aiur_fn_245(__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_246] = { let __args: [G; IN_246] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[246].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_246] = unsafe { *(result.output.as_ptr() as *const [G; OUT_246]) }; __ret } else { aiur_fn_246(__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_247] = { let __args: [G; IN_247] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[247].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_247] = unsafe { *(result.output.as_ptr() as *const [G; OUT_247]) }; __ret } else { aiur_fn_247(__args, record, io_buffer, __cu)? } };
-    let __v_29: G = __r_arr[0];
-    let __v_30: G = G::from_u64(0);
-    let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[248].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_248] = unsafe { *(result.output.as_ptr() as *const [G; OUT_248]) }; __ret } else { aiur_fn_248(__args, record, io_buffer, __cu)? } };
-    let __v_31: G = __r_arr[0];
-    let __v_32: G = G::from_u64(0);
-    let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[249].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_249] = unsafe { *(result.output.as_ptr() as *const [G; OUT_249]) }; __ret } else { aiur_fn_249(__args, record, io_buffer, __cu)? } };
-    let __v_33: G = __r_arr[0];
-    let __v_34: G = G::from_u64(0);
-    let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[250].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_250] = unsafe { *(result.output.as_ptr() as *const [G; OUT_250]) }; __ret } else { aiur_fn_250(__args, record, io_buffer, __cu)? } };
-    let __v_35: G = __r_arr[0];
-    let __v_36: G = G::from_u64(0);
-    let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } else { aiur_fn_251(__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_252] = { let __args: [G; IN_252] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } else { aiur_fn_252(__args, record, io_buffer, __cu)? } };
-    let __v_39: G = __r_arr[0];
-    let __v_40: G = G::from_u64(0);
-    let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[253].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_253] = unsafe { *(result.output.as_ptr() as *const [G; OUT_253]) }; __ret } else { aiur_fn_253(__args, record, io_buffer, __cu)? } };
-    let __v_41: G = __r_arr[0];
-    let __v_42: G = G::from_u64(0);
-    let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } else { aiur_fn_254(__args, record, io_buffer, __cu)? } };
-    let __v_43: G = __r_arr[0];
-    let __v_44: G = G::from_u64(0);
-    let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } else { aiur_fn_255(__args, record, io_buffer, __cu)? } };
-    let __v_45: G = __r_arr[0];
-    let __v_46: G = G::from_u64(0);
-    let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[256].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_256] = unsafe { *(result.output.as_ptr() as *const [G; OUT_256]) }; __ret } else { aiur_fn_256(__args, record, io_buffer, __cu)? } };
-    let __v_47: G = __r_arr[0];
-    let __v_48: G = G::from_u64(0);
-    let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[257].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_257] = unsafe { *(result.output.as_ptr() as *const [G; OUT_257]) }; __ret } else { aiur_fn_257(__args, record, io_buffer, __cu)? } };
-    let __v_49: G = __r_arr[0];
-    let __v_50: G = G::from_u64(0);
-    let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[258].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_258] = unsafe { *(result.output.as_ptr() as *const [G; OUT_258]) }; __ret } else { aiur_fn_258(__args, record, io_buffer, __cu)? } };
-    let __v_51: G = __r_arr[0];
-    let __v_52: G = G::from_u64(0);
-    let __r_arr: [G; OUT_259] = { let __args: [G; IN_259] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[259].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_259] = unsafe { *(result.output.as_ptr() as *const [G; OUT_259]) }; __ret } else { aiur_fn_259(__args, record, io_buffer, __cu)? } };
-    let __v_53: G = __r_arr[0];
-    let __v_54: G = G::from_u64(0);
-    let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[260].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_260] = unsafe { *(result.output.as_ptr() as *const [G; OUT_260]) }; __ret } else { aiur_fn_260(__args, record, io_buffer, __cu)? } };
-    let __v_55: G = __r_arr[0];
-    let __v_56: G = G::from_u64(0);
-    let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[261].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_261] = unsafe { *(result.output.as_ptr() as *const [G; OUT_261]) }; __ret } else { aiur_fn_261(__args, record, io_buffer, __cu)? } };
-    let __v_57: G = __r_arr[0];
-    let __v_58: G = G::from_u64(0);
-    let __r_arr: [G; OUT_262] = { let __args: [G; IN_262] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[262].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_262] = unsafe { *(result.output.as_ptr() as *const [G; OUT_262]) }; __ret } else { aiur_fn_262(__args, record, io_buffer, __cu)? } };
-    let __v_59: G = __r_arr[0];
-    let __v_60: G = G::from_u64(0);
-    let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[263].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_263] = unsafe { *(result.output.as_ptr() as *const [G; OUT_263]) }; __ret } else { aiur_fn_263(__args, record, io_buffer, __cu)? } };
-    let __v_61: G = __r_arr[0];
-    let __v_62: G = G::from_u64(0);
-    let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[264].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_264] = unsafe { *(result.output.as_ptr() as *const [G; OUT_264]) }; __ret } else { aiur_fn_264(__args, record, io_buffer, __cu)? } };
-    let __v_63: G = __r_arr[0];
-    let __v_64: G = G::from_u64(0);
-    let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[265].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_265] = unsafe { *(result.output.as_ptr() as *const [G; OUT_265]) }; __ret } else { aiur_fn_265(__args, record, io_buffer, __cu)? } };
-    let __v_65: G = __r_arr[0];
-    let __v_66: G = G::from_u64(0);
-    let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[266].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_266] = unsafe { *(result.output.as_ptr() as *const [G; OUT_266]) }; __ret } else { aiur_fn_266(__args, record, io_buffer, __cu)? } };
-    let __v_67: G = __r_arr[0];
-    let __v_68: G = G::from_u64(0);
-    let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = unsafe { *(result.output.as_ptr() as *const [G; OUT_267]) }; __ret } else { aiur_fn_267(__args, record, io_buffer, __cu)? } };
-    let __v_69: G = __r_arr[0];
-    let __v_70: G = G::from_u64(0);
-    let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } else { aiur_fn_268(__args, record, io_buffer, __cu)? } };
-    let __v_71: G = __r_arr[0];
-    let __v_72: G = G::from_u64(0);
-    let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } else { aiur_fn_269(__args, record, io_buffer, __cu)? } };
-    let __v_73: G = __r_arr[0];
-    let __v_74: G = G::from_u64(0);
-    let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[270].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_270] = unsafe { *(result.output.as_ptr() as *const [G; OUT_270]) }; __ret } else { aiur_fn_270(__args, record, io_buffer, __cu)? } };
-    let __v_75: G = __r_arr[0];
-    let __v_76: G = G::from_u64(0);
-    let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[271].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_271] = unsafe { *(result.output.as_ptr() as *const [G; OUT_271]) }; __ret } else { aiur_fn_271(__args, record, io_buffer, __cu)? } };
-    let __v_77: G = __r_arr[0];
-    let __v_78: G = G::from_u64(0);
-    let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } else { aiur_fn_272(__args, record, io_buffer, __cu)? } };
-    let __v_79: G = __r_arr[0];
-    let __v_80: G = G::from_u64(0);
-    let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[273].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_273] = unsafe { *(result.output.as_ptr() as *const [G; OUT_273]) }; __ret } else { aiur_fn_273(__args, record, io_buffer, __cu)? } };
-    let __v_81: G = __r_arr[0];
-    let __v_82: G = G::from_u64(0);
-    let __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[274].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_274] = unsafe { *(result.output.as_ptr() as *const [G; OUT_274]) }; __ret } else { aiur_fn_274(__args, record, io_buffer, __cu)? } };
-    let __v_83: G = __r_arr[0];
-    let __v_84: G = G::from_u64(0);
-    let __r_arr: [G; OUT_275] = { let __args: [G; IN_275] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[275].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_275] = unsafe { *(result.output.as_ptr() as *const [G; OUT_275]) }; __ret } else { aiur_fn_275(__args, record, io_buffer, __cu)? } };
-    let __v_85: G = __r_arr[0];
-    let __v_86: G = G::from_u64(0);
-    let __r_arr: [G; OUT_276] = { let __args: [G; IN_276] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[276].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_276] = unsafe { *(result.output.as_ptr() as *const [G; OUT_276]) }; __ret } else { aiur_fn_276(__args, record, io_buffer, __cu)? } };
-    let __v_87: G = __r_arr[0];
-    let __v_88: G = G::from_u64(0);
-    let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[277].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_277] = unsafe { *(result.output.as_ptr() as *const [G; OUT_277]) }; __ret } else { aiur_fn_277(__args, record, io_buffer, __cu)? } };
-    let __v_89: G = __r_arr[0];
-    let __v_90: G = G::from_u64(0);
-    let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } else { aiur_fn_278(__args, record, io_buffer, __cu)? } };
-    let __v_91: G = __r_arr[0];
-    let __v_92: G = G::from_u64(0);
-    let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } else { aiur_fn_279(__args, record, io_buffer, __cu)? } };
-    let __v_93: G = __r_arr[0];
-    let __v_94: G = G::from_u64(0);
-    let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[280].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_280] = unsafe { *(result.output.as_ptr() as *const [G; OUT_280]) }; __ret } else { aiur_fn_280(__args, record, io_buffer, __cu)? } };
-    let __v_95: G = __r_arr[0];
-    let __v_96: G = G::from_u64(0);
-    let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[281].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_281] = unsafe { *(result.output.as_ptr() as *const [G; OUT_281]) }; __ret } else { aiur_fn_281(__args, record, io_buffer, __cu)? } };
-    let __v_97: G = __r_arr[0];
-    let __v_98: G = G::from_u64(0);
-    let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } else { aiur_fn_282(__args, record, io_buffer, __cu)? } };
-    let __v_99: G = __r_arr[0];
-    let __v_100: G = G::from_u64(0);
-    let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } else { aiur_fn_283(__args, record, io_buffer, __cu)? } };
-    let __v_101: G = __r_arr[0];
-    let __v_102: G = G::from_u64(0);
-    let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } else { aiur_fn_284(__args, record, io_buffer, __cu)? } };
-    let __v_103: G = __r_arr[0];
-    let __v_104: G = G::from_u64(0);
-    let __r_arr: [G; OUT_285] = { let __args: [G; IN_285] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[285].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_285] = unsafe { *(result.output.as_ptr() as *const [G; OUT_285]) }; __ret } else { aiur_fn_285(__args, record, io_buffer, __cu)? } };
-    let __v_105: G = __r_arr[0];
-    let __v_106: G = G::from_u64(0);
-    let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } else { aiur_fn_286(__args, record, io_buffer, __cu)? } };
-    let __v_107: G = __r_arr[0];
-    let __v_108: G = G::from_u64(0);
-    let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } else { aiur_fn_287(__args, record, io_buffer, __cu)? } };
-    let __v_109: G = __r_arr[0];
-    let __v_110: G = G::from_u64(0);
-    let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[288].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_288] = unsafe { *(result.output.as_ptr() as *const [G; OUT_288]) }; __ret } else { aiur_fn_288(__args, record, io_buffer, __cu)? } };
-    let __v_111: G = __r_arr[0];
-    let __v_112: G = G::from_u64(0);
-    let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } else { aiur_fn_289(__args, record, io_buffer, __cu)? } };
-    let __v_113: G = __r_arr[0];
-    let __v_114: G = G::from_u64(0);
-    let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } else { aiur_fn_290(__args, record, io_buffer, __cu)? } };
-    let __v_115: G = __r_arr[0];
-    let __v_116: G = G::from_u64(0);
-    let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[291].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_291] = unsafe { *(result.output.as_ptr() as *const [G; OUT_291]) }; __ret } else { aiur_fn_291(__args, record, io_buffer, __cu)? } };
-    let __v_117: G = __r_arr[0];
-    let __v_118: G = G::from_u64(0);
-    let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[292].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_292] = unsafe { *(result.output.as_ptr() as *const [G; OUT_292]) }; __ret } else { aiur_fn_292(__args, record, io_buffer, __cu)? } };
-    let __v_119: G = __r_arr[0];
-    let __v_120: G = G::from_u64(0);
-    let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[293].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_293] = unsafe { *(result.output.as_ptr() as *const [G; OUT_293]) }; __ret } else { aiur_fn_293(__args, record, io_buffer, __cu)? } };
-    let __v_121: G = __r_arr[0];
-    let __v_122: G = G::from_u64(0);
-    let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } else { aiur_fn_294(__args, record, io_buffer, __cu)? } };
-    let __v_123: G = __r_arr[0];
-    let __v_124: G = G::from_u64(0);
-    let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } else { aiur_fn_295(__args, record, io_buffer, __cu)? } };
-    let __v_125: G = __r_arr[0];
-    let __v_126: G = G::from_u64(0);
-    let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[296].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_296] = unsafe { *(result.output.as_ptr() as *const [G; OUT_296]) }; __ret } else { aiur_fn_296(__args, record, io_buffer, __cu)? } };
-    let __v_127: G = __r_arr[0];
-    let __v_128: G = G::from_u64(0);
-    let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } else { aiur_fn_297(__args, record, io_buffer, __cu)? } };
-    let __v_129: G = __r_arr[0];
-    let __v_130: G = G::from_u64(0);
-    let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[300].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_300] = unsafe { *(result.output.as_ptr() as *const [G; OUT_300]) }; __ret } else { aiur_fn_300(__args, record, io_buffer, __cu)? } };
-    let __v_131: G = __r_arr[0];
-    let __v_132: G = G::from_u64(0);
-    let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[301].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_301] = unsafe { *(result.output.as_ptr() as *const [G; OUT_301]) }; __ret } else { aiur_fn_301(__args, record, io_buffer, __cu)? } };
-    let __v_133: G = __r_arr[0];
-    let __v_134: G = G::from_u64(0);
-    let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[302].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_302] = unsafe { *(result.output.as_ptr() as *const [G; OUT_302]) }; __ret } else { aiur_fn_302(__args, record, io_buffer, __cu)? } };
-    let __v_135: G = __r_arr[0];
-    let __v_136: G = G::from_u64(0);
-    let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[303].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_303] = unsafe { *(result.output.as_ptr() as *const [G; OUT_303]) }; __ret } else { aiur_fn_303(__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 __v_141: G = { let __values: [G; 3] = [__v_136, __v_137, __v_140]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_142: G = { let __values: [G; 3] = [__v_134, __v_135, __v_141]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_143: G = { let __values: [G; 3] = [__v_132, __v_133, __v_142]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_144: G = { let __values: [G; 3] = [__v_130, __v_131, __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 __v_145: G = { let __values: [G; 3] = [__v_128, __v_129, __v_144]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_146: G = { let __values: [G; 3] = [__v_126, __v_127, __v_145]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_147: G = { let __values: [G; 3] = [__v_124, __v_125, __v_146]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_148: G = { let __values: [G; 3] = [__v_122, __v_123, __v_147]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_149: G = { let __values: [G; 3] = [__v_120, __v_121, __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 __v_150: G = { let __values: [G; 3] = [__v_118, __v_119, __v_149]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_151: G = { let __values: [G; 3] = [__v_116, __v_117, __v_150]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_152: G = { let __values: [G; 3] = [__v_114, __v_115, __v_151]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_153: G = { let __values: [G; 3] = [__v_112, __v_113, __v_152]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_154: G = { let __values: [G; 3] = [__v_110, __v_111, __v_153]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_155: G = { let __values: [G; 3] = [__v_108, __v_109, __v_154]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_156: G = { let __values: [G; 3] = [__v_106, __v_107, __v_155]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_157: G = { let __values: [G; 3] = [__v_104, __v_105, __v_156]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_158: G = { let __values: [G; 3] = [__v_102, __v_103, __v_157]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_159: G = { let __values: [G; 3] = [__v_100, __v_101, __v_158]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_160: G = { let __values: [G; 3] = [__v_98, __v_99, __v_159]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_161: G = { let __values: [G; 3] = [__v_96, __v_97, __v_160]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_162: G = { let __values: [G; 3] = [__v_94, __v_95, __v_161]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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; 3] = [__v_92, __v_93, __v_162]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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; 3] = [__v_90, __v_91, __v_163]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_165: G = { let __values: [G; 3] = [__v_88, __v_89, __v_164]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_166: G = { let __values: [G; 3] = [__v_86, __v_87, __v_165]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_167: G = { let __values: [G; 3] = [__v_84, __v_85, __v_166]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_168: G = { let __values: [G; 3] = [__v_82, __v_83, __v_167]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_169: G = { let __values: [G; 3] = [__v_80, __v_81, __v_168]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_170: G = { let __values: [G; 3] = [__v_78, __v_79, __v_169]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_171: G = { let __values: [G; 3] = [__v_76, __v_77, __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 __v_172: G = { let __values: [G; 3] = [__v_74, __v_75, __v_171]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_173: G = { let __values: [G; 3] = [__v_72, __v_73, __v_172]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_174: G = { let __values: [G; 3] = [__v_70, __v_71, __v_173]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_175: G = { let __values: [G; 3] = [__v_68, __v_69, __v_174]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_176: G = { let __values: [G; 3] = [__v_66, __v_67, __v_175]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_177: G = { let __values: [G; 3] = [__v_64, __v_65, __v_176]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_178: G = { let __values: [G; 3] = [__v_62, __v_63, __v_177]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_179: G = { let __values: [G; 3] = [__v_60, __v_61, __v_178]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_180: G = { let __values: [G; 3] = [__v_58, __v_59, __v_179]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_181: G = { let __values: [G; 3] = [__v_56, __v_57, __v_180]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_182: G = { let __values: [G; 3] = [__v_54, __v_55, __v_181]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_183: G = { let __values: [G; 3] = [__v_52, __v_53, __v_182]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_184: G = { let __values: [G; 3] = [__v_50, __v_51, __v_183]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_185: G = { let __values: [G; 3] = [__v_48, __v_49, __v_184]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_186: G = { let __values: [G; 3] = [__v_46, __v_47, __v_185]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_187: G = { let __values: [G; 3] = [__v_44, __v_45, __v_186]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_188: G = { let __values: [G; 3] = [__v_42, __v_43, __v_187]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_189: G = { let __values: [G; 3] = [__v_40, __v_41, __v_188]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_190: G = { let __values: [G; 3] = [__v_38, __v_39, __v_189]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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; 3] = [__v_36, __v_37, __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 = { let __values: [G; 3] = [__v_34, __v_35, __v_191]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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; 3] = [__v_32, __v_33, __v_192]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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; 3] = [__v_30, __v_31, __v_193]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_195: G = { let __values: [G; 3] = [__v_28, __v_29, __v_194]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_196: G = { let __values: [G; 3] = [__v_26, __v_27, __v_195]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_197: G = { let __values: [G; 3] = [__v_24, __v_25, __v_196]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_198: G = { let __values: [G; 3] = [__v_22, __v_23, __v_197]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_199: G = { let __values: [G; 3] = [__v_20, __v_21, __v_198]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_200: G = { let __values: [G; 3] = [__v_18, __v_19, __v_199]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_201: G = { let __values: [G; 3] = [__v_16, __v_17, __v_200]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_202: G = { let __values: [G; 3] = [__v_14, __v_15, __v_201]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_203: G = { let __values: [G; 3] = [__v_12, __v_13, __v_202]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_204: G = { let __values: [G; 3] = [__v_10, __v_11, __v_203]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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 = { let __values: [G; 3] = [__v_8, __v_9, __v_204]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_206: G = { let __values: [G; 3] = [__v_6, __v_7, __v_205]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_207: G = { let __values: [G; 3] = [__v_4, __v_5, __v_206]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_208: G = { let __values: [G; 3] = [__v_2, __v_3, __v_207]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_209: G = { let __values: [G; 3] = [__v_0, __v_1, __v_208]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_209];
-    record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_187: usize = 1;
-const IN_187: usize = 1;
-const OUT_187: usize = 1;
-fn aiur_fn_187(
-  inp: [G; IN_187],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_187], 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_187] = [__v_4];
-        record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { 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_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_187] = [__v_6];
-        record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_188: usize = 2;
-const IN_188: usize = 2;
-const OUT_188: usize = 1;
-fn aiur_fn_188(
-  inp: [G; IN_188],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> 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];
-    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_188] = [__v_4];
-        record.function_queries[188].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(1);
-        let __v_4: G = (__v_1 - __v_3);
-        let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[188].get_mut(&__args[..]) { 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 __v_5: G = __r_arr[0];
-        let __v_6: G = { let __values: [G; 3] = [__v_2, __v_0, __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_188] = [__v_6];
-        record.function_queries[188].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],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_189], 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() {
-      3u64 => {
-        let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[189].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_189] = unsafe { *(result.output.as_ptr() as *const [G; OUT_189]) }; __ret } else { aiur_fn_189(__args, record, io_buffer, __cu)? } };
-        let __v_5: G = __r_arr[0];
-        let __v_6: G = __r_arr[1];
-        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_6, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
-        let __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_189] = [__v_5, __v_7];
-        record.function_queries[189].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        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_189] = [__v_0, __v_7];
-        record.function_queries[189].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_190: usize = 1;
-const IN_190: usize = 1;
-const OUT_190: usize = 1;
-fn aiur_fn_190(
-  inp: [G; IN_190],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_190], 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 __v_4: G = G::from_u64(0);
-        let __ret: [G; OUT_190] = [__v_4];
-        record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      4u64 => {
-        let __v_4: G = G::from_u64(0);
-        let __ret: [G; OUT_190] = [__v_4];
-        record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      1u64 => {
-        let __v_4: G = G::from_u64(1);
-        let __ret: [G; OUT_190] = [__v_4];
-        record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      2u64 => {
-        let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[190].get_mut(&__args[..]) { 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_4: G = __r_arr[0];
-        let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[190].get_mut(&__args[..]) { 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_5: G = __r_arr[0];
-        match __v_4.as_canonical_u64() {
-          0u64 => {
-            match __v_5.as_canonical_u64() {
-              0u64 => {
-                let __v_6: G = G::from_u64(0);
-                let __ret: [G; OUT_190] = [__v_6];
-                record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              _ => {
-                let __v_6: G = G::from_u64(1);
-                let __ret: [G; OUT_190] = [__v_6];
-                record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-            }
-          },
-          _ => {
-            let __v_6: G = G::from_u64(1);
-            let __ret: [G; OUT_190] = [__v_6];
-            record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-        }
-      },
-      3u64 => {
-        let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[190].get_mut(&__args[..]) { 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_4: G = __r_arr[0];
-        let __ret: [G; OUT_190] = [__v_4];
-        record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_191: usize = 2;
-const IN_191: usize = 2;
-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_191], 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() {
-      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_5: G = __loaded[0];
-        let __v_6: G = __loaded[1];
-        let __v_7: G = __loaded[2];
-        match __v_5.as_canonical_u64() {
-          0u64 => {
-            let __v_8: G = G::from_u64(1);
-            let __ret: [G; OUT_191] = [__v_8];
-            record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_191] = [__v_8];
-            record.function_queries[191].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_5: G = __loaded[0];
-        let __v_6: G = __loaded[1];
-        let __v_7: G = __loaded[2];
-        match __v_5.as_canonical_u64() {
-          1u64 => {
-            let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[191].get_mut(&__args[..]) { 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_8: G = __r_arr[0];
-            let __ret: [G; OUT_191] = [__v_8];
-            record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_191] = [__v_8];
-            record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-        }
-      },
-      2u64 => {
-        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_5: G = __loaded[0];
-        let __v_6: G = __loaded[1];
-        let __v_7: G = __loaded[2];
-        match __v_5.as_canonical_u64() {
-          2u64 => {
-            let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[191].get_mut(&__args[..]) { 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_8: G = __r_arr[0];
-            let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[191].get_mut(&__args[..]) { 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_9: G = __r_arr[0];
-            let __v_10: G = (__v_8 * __v_9);
-            let __ret: [G; OUT_191] = [__v_10];
-            record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_191] = [__v_8];
-            record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-        }
-      },
-      3u64 => {
-        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_5: G = __loaded[0];
-        let __v_6: G = __loaded[1];
-        let __v_7: G = __loaded[2];
-        match __v_5.as_canonical_u64() {
-          3u64 => {
-            let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[191].get_mut(&__args[..]) { 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_8: G = __r_arr[0];
-            let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[191].get_mut(&__args[..]) { 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_9: G = __r_arr[0];
-            let __v_10: G = (__v_8 * __v_9);
-            let __ret: [G; OUT_191] = [__v_10];
-            record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_191] = [__v_8];
-            record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-        }
-      },
-      4u64 => {
-        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_5: G = __loaded[0];
-        let __v_6: G = __loaded[1];
-        let __v_7: G = __loaded[2];
-        match __v_5.as_canonical_u64() {
-          4u64 => {
-            let __v_8: G = (__v_3 - __v_6);
-            let __v_9: G = G::from_bool((__v_8 == G::ZERO));
-            let __ret: [G; OUT_191] = [__v_9];
-            record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_191] = [__v_8];
-            record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-        }
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_192: usize = 2;
-const IN_192: usize = 2;
-const OUT_192: usize = 1;
-fn aiur_fn_192(
-  inp: [G; IN_192],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> 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];
-    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 __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_5: G = __loaded[0];
-        let __v_6: G = __loaded[1];
-        let __v_7: G = __loaded[2];
-        match __v_5.as_canonical_u64() {
-          1u64 => {
-            let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_192] = [__v_8];
-            record.function_queries[192].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          0u64 => {
-            let __v_8: G = G::from_u64(1);
-            let __ret: [G; OUT_192] = [__v_8];
-            record.function_queries[192].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__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_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_5: G = __loaded[0];
-        let __v_6: G = __loaded[1];
-        let __v_7: G = __loaded[2];
-        match __v_5.as_canonical_u64() {
-          1u64 => {
-            let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_192] = [__v_8];
-            record.function_queries[192].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          0u64 => {
-            let __v_8: G = { let __a_val = __v_3.as_canonical_u64(); let __b_val = __v_6.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_8.as_canonical_u64() {
-              1u64 => {
-                let __v_9: G = G::from_u64(1);
-                let __ret: [G; OUT_192] = [__v_9];
-                record.function_queries[192].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              0u64 => {
-                let __v_9: G = { let __a_val = __v_6.as_canonical_u64(); let __b_val = __v_3.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_9.as_canonical_u64() {
-                  1u64 => {
-                    let __v_10: G = G::from_u64(2);
-                    let __ret: [G; OUT_192] = [__v_10];
-                    record.function_queries[192].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
-                  0u64 => {
-                    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 !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_10: G = __r_arr[0];
-                    let __ret: [G; OUT_192] = [__v_10];
-                    record.function_queries[192].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
-                  _ => {
-                    return Err(ExecError::MatchNoCase(__v_9.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_193: usize = 2;
-const IN_193: usize = 2;
-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_193], 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(1);
-        let __ret: [G; OUT_193] = [__v_5];
-        record.function_queries[193].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_5: G = __loaded[0];
-        let __v_6: G = __loaded[1];
-        let __v_7: G = __loaded[2];
-        match __v_5.as_canonical_u64() {
-          1u64 => {
-            let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_193] = [__v_8];
-            record.function_queries[193].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          0u64 => {
-            let __v_8: G = { let __a_val = __v_3.as_canonical_u64(); let __b_val = __v_6.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_8.as_canonical_u64() {
-              1u64 => {
-                let __v_9: G = G::from_u64(0);
-                let __ret: [G; OUT_193] = [__v_9];
-                record.function_queries[193].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              0u64 => {
-                let __v_9: G = { let __a_val = __v_6.as_canonical_u64(); let __b_val = __v_3.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_9.as_canonical_u64() {
-                  1u64 => {
-                    let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[193].get_mut(&__args[..]) { 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_10: G = __r_arr[0];
-                    let __ret: [G; OUT_193] = [__v_10];
-                    record.function_queries[193].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
-                  0u64 => {
-                    let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[193].get_mut(&__args[..]) { 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_10: G = __r_arr[0];
-                    let __ret: [G; OUT_193] = [__v_10];
-                    record.function_queries[193].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
-                  _ => {
-                    return Err(ExecError::MatchNoCase(__v_9.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_194: usize = 2;
-const IN_194: usize = 2;
-const OUT_194: usize = 1;
-fn aiur_fn_194(
-  inp: [G; IN_194],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> 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];
-    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 __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_5: G = __loaded[0];
-        let __v_6: G = __loaded[1];
-        let __v_7: G = __loaded[2];
-        match __v_5.as_canonical_u64() {
-          1u64 => {
-            let __v_8: G = G::from_u64(1);
-            let __ret: [G; OUT_194] = [__v_8];
-            record.function_queries[194].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          0u64 => {
-            let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_194] = [__v_8];
-            record.function_queries[194].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__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_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_5: G = __loaded[0];
-        let __v_6: G = __loaded[1];
-        let __v_7: G = __loaded[2];
-        match __v_5.as_canonical_u64() {
-          1u64 => {
-            let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_194] = [__v_8];
-            record.function_queries[194].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          0u64 => {
-            let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { 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_8: G = __r_arr[0];
-            let __ret: [G; OUT_194] = [__v_8];
-            record.function_queries[194].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
-          },
-        }
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_195: usize = 2;
-const IN_195: usize = 2;
-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_195], 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 __v_6: G = G::from_u64(0);
-        let __v_7: G = G::from_u64(1);
-        let __v_8: G = G::from_u64(1);
-        let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __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_10: G = { let __values: [G; 3] = [__v_6, __v_0, __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 __ret: [G; OUT_195] = [__v_5, __v_10];
-        record.function_queries[195].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __v_5: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_3.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() {
-          1u64 => {
-            let __v_6: G = G::from_u64(1);
-            let __v_7: G = G::from_u64(0);
-            let __v_8: G = { let __values: [G; 3] = [__v_7, __v_0, __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_195] = [__v_6, __v_8];
-            record.function_queries[195].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          0u64 => {
-            let __v_6: G = { let __a_val = __v_3.as_canonical_u64(); let __b_val = __v_0.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_6.as_canonical_u64() {
-              0u64 => {
-                let __v_7: G = G::from_u64(0);
-                let __ret: [G; OUT_195] = [__v_7, __v_1];
-                record.function_queries[195].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              1u64 => {
-                let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[195].get_mut(&__args[..]) { 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_7: G = __r_arr[0];
-                let __v_8: G = __r_arr[1];
-                let __v_9: G = G::from_u64(0);
-                let __v_10: G = { let __values: [G; 3] = [__v_9, __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_195] = [__v_7, __v_10];
-                record.function_queries[195].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              _ => {
-                return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64()));
-              },
-            }
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
-          },
-        }
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_196: usize = 3;
-const IN_196: usize = 3;
-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_196], 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(0);
-        let __v_7: G = { let __values: [G; 2] = [__v_1, __v_2]; let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_8: G = G::from_u64(1);
-        let __v_9: G = G::from_u64(1);
-        let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __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_7, __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 __ret: [G; OUT_196] = [__v_11];
-        record.function_queries[196].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; 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: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
-        let __v_6: G = __loaded[0];
-        let __v_7: G = __loaded[1];
-        match __v_6.as_canonical_u64() {
-          _ => {
-            let __v_8: G = { let __a_val = __v_1.as_canonical_u64(); let __b_val = __v_6.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_8.as_canonical_u64() {
-              1u64 => {
-                let __v_9: G = G::from_u64(0);
-                let __v_10: G = { let __values: [G; 2] = [__v_1, __v_2]; let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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_9, __v_10, __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 __ret: [G; OUT_196] = [__v_11];
-                record.function_queries[196].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              0u64 => {
-                let __v_9: G = { let __a_val = __v_6.as_canonical_u64(); let __b_val = __v_1.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_9.as_canonical_u64() {
-                  1u64 => {
-                    let __v_10: G = G::from_u64(0);
-                    let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { 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_11: G = __r_arr[0];
-                    let __v_12: G = { let __values: [G; 3] = [__v_10, __v_4, __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_196] = [__v_12];
-                    record.function_queries[196].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
-                  0u64 => {
-                    let __v_10: G = { let __a_val = __v_7.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_10.as_canonical_u64() {
-                      1u64 => {
-                        let __v_11: G = G::from_u64(0);
-                        let __v_12: G = { let __values: [G; 2] = [__v_6, __v_2]; let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                        let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __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_196] = [__v_13];
-                        record.function_queries[196].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                        return Ok(__ret);
-                      },
-                      0u64 => {
-                        let __ret: [G; OUT_196] = [__v_0];
-                        record.function_queries[196].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                        return Ok(__ret);
-                      },
-                      _ => {
-                        return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64()));
-                      },
-                    }
-                  },
-                  _ => {
-                    return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64()));
-                  },
-                }
-              },
-              _ => {
-                return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64()));
-              },
-            }
-          },
-        }
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_197: usize = 2;
-const IN_197: usize = 2;
-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_197], 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 __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_5: G = __loaded[0];
-        let __v_6: G = __loaded[1];
-        let __v_7: G = __loaded[2];
-        match __v_5.as_canonical_u64() {
-          1u64 => {
-            let __v_8: G = G::from_u64(1);
-            let __ret: [G; OUT_197] = [__v_8];
-            record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          0u64 => {
-            let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_197] = [__v_8];
-            record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__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_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_5: G = __loaded[0];
-        let __v_6: G = __loaded[1];
-        let __v_7: G = __loaded[2];
-        match __v_5.as_canonical_u64() {
-          1u64 => {
-            let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_197] = [__v_8];
-            record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          0u64 => {
-            let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; 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: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
-            let __v_8: G = __loaded[0];
-            let __v_9: G = __loaded[1];
-            match __v_8.as_canonical_u64() {
-              _ => {
-                let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; 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: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
-                let __v_10: G = __loaded[0];
-                let __v_11: G = __loaded[1];
-                match __v_10.as_canonical_u64() {
-                  _ => {
-                    let __v_12: G = (__v_8 - __v_10);
-                    match __v_12.as_canonical_u64() {
-                      0u64 => {
-                        let __v_13: G = (__v_9 - __v_11);
-                        match __v_13.as_canonical_u64() {
-                          0u64 => {
-                            let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[197].get_mut(&__args[..]) { 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_14: G = __r_arr[0];
-                            let __ret: [G; OUT_197] = [__v_14];
-                            record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                            return Ok(__ret);
-                          },
-                          _ => {
-                            let __v_14: G = G::from_u64(0);
-                            let __ret: [G; OUT_197] = [__v_14];
-                            record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                            return Ok(__ret);
-                          },
-                        }
-                      },
-                      _ => {
-                        let __v_13: G = G::from_u64(0);
-                        let __ret: [G; OUT_197] = [__v_13];
-                        record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                        return Ok(__ret);
-                      },
-                    }
-                  },
-                }
-              },
-            }
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
-          },
-        }
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_198: usize = 1;
-const IN_198: usize = 1;
-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_198], 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_198] = [__v_4];
-        record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; 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: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
-        let __v_4: G = __loaded[0];
-        let __v_5: G = __loaded[1];
-        match __v_4.as_canonical_u64() {
-          _ => {
-            let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { 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 __v_7: G = { let __a_val = __v_6.as_canonical_u64(); let __b_val = __v_5.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_7.as_canonical_u64() {
-              1u64 => {
-                let __ret: [G; OUT_198] = [__v_5];
-                record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              0u64 => {
-                let __ret: [G; OUT_198] = [__v_6];
-                record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              _ => {
-                return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64()));
-              },
-            }
-          },
-        }
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-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_199], 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_199] = [__v_0];
-        record.function_queries[199].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_5: G = __loaded[0];
-        let __v_6: G = __loaded[1];
-        let __v_7: G = __loaded[2];
-        match __v_5.as_canonical_u64() {
-          1u64 => {
-            let __ret: [G; OUT_199] = [__v_0];
-            record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          0u64 => {
-            let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; 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: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
-            let __v_8: G = __loaded[0];
-            let __v_9: G = __loaded[1];
-            match __v_8.as_canonical_u64() {
-              _ => {
-                let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; 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: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
-                let __v_10: G = __loaded[0];
-                let __v_11: G = __loaded[1];
-                match __v_10.as_canonical_u64() {
-                  _ => {
-                    let __v_12: G = { let __a_val = __v_8.as_canonical_u64(); let __b_val = __v_10.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_12.as_canonical_u64() {
-                      1u64 => {
-                        let __v_13: G = G::from_u64(0);
-                        let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { 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_14: G = __r_arr[0];
-                        let __v_15: G = { let __values: [G; 3] = [__v_13, __v_3, __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_199] = [__v_15];
-                        record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                        return Ok(__ret);
-                      },
-                      0u64 => {
-                        let __v_13: G = { let __a_val = __v_10.as_canonical_u64(); let __b_val = __v_8.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_13.as_canonical_u64() {
-                          1u64 => {
-                            let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { 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_14: G = __r_arr[0];
-                            let __ret: [G; OUT_199] = [__v_14];
-                            record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                            return Ok(__ret);
-                          },
-                          0u64 => {
-                            let __v_14: G = { let __a_val = __v_11.as_canonical_u64(); let __b_val = __v_9.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_14.as_canonical_u64() {
-                              1u64 => {
-                                let __v_15: G = G::from_u64(0);
-                                let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { 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_16: G = __r_arr[0];
-                                let __v_17: G = { let __values: [G; 3] = [__v_15, __v_3, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_199] = [__v_17];
-                                record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                return Ok(__ret);
-                              },
-                              0u64 => {
-                                let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { 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_15: G = __r_arr[0];
-                                let __ret: [G; OUT_199] = [__v_15];
-                                record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                return Ok(__ret);
-                              },
-                              _ => {
-                                return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64()));
-                              },
-                            }
-                          },
-                          _ => {
-                            return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64()));
-                          },
-                        }
-                      },
-                      _ => {
-                        return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64()));
-                      },
-                    }
-                  },
-                }
-              },
-            }
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
-          },
-        }
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_200: usize = 3;
-const IN_200: usize = 3;
-const OUT_200: usize = 1;
-fn aiur_fn_200(
-  inp: [G; IN_200],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_200], 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_2.as_canonical_u64() {
-      0u64 => {
-        let __ret: [G; OUT_200] = [__v_0];
-        record.function_queries[200].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_3: G = __loaded[0];
-        let __v_4: G = __loaded[1];
-        let __v_5: G = __loaded[2];
-        match __v_3.as_canonical_u64() {
-          1u64 => {
-            let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { 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_6: G = __r_arr[0];
-            let __ret: [G; OUT_200] = [__v_6];
-            record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          0u64 => {
-            let __ret: [G; OUT_200] = [__v_0];
-            record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
-          },
-        }
-      },
-      _ => {
-        let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { 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 __ret: [G; OUT_200] = [__v_3];
-        record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_201: usize = 3;
-const IN_201: usize = 3;
-const OUT_201: usize = 1;
-fn aiur_fn_201(
-  inp: [G; IN_201],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> 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];
-    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(0);
-        let __v_7: G = G::from_u64(1);
-        let __v_8: G = G::from_u64(1);
-        let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __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_10: G = { let __values: [G; 3] = [__v_1, __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 = 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 __v_14: G = { let __values: [G; 3] = [__v_6, __v_10, __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 __ret: [G; OUT_201] = [__v_14];
-        record.function_queries[201].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_6: G = __loaded[0];
-        let __v_7: G = __loaded[1];
-        let __v_8: G = __loaded[2];
-        match __v_6.as_canonical_u64() {
-          _ => {
-            let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { 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_9: G = __r_arr[0];
-            match __v_9.as_canonical_u64() {
-              0u64 => {
-                let __v_10: G = { let __a_val = __v_7.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_10.as_canonical_u64() {
-                  1u64 => {
-                    let __v_11: G = G::from_u64(0);
-                    let __v_12: G = { let __values: [G; 3] = [__v_6, __v_2, __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_13: G = { let __values: [G; 3] = [__v_11, __v_12, __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_201] = [__v_13];
-                    record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
-                  0u64 => {
-                    let __ret: [G; OUT_201] = [__v_0];
-                    record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
-                  _ => {
-                    return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64()));
-                  },
-                }
-              },
-              1u64 => {
-                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 = { 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 __v_14: G = { let __values: [G; 3] = [__v_1, __v_2, __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_15: G = { let __values: [G; 3] = [__v_10, __v_14, __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 __ret: [G; OUT_201] = [__v_15];
-                record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              _ => {
-                let __v_10: G = G::from_u64(0);
-                let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { 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_11: G = __r_arr[0];
-                let __v_12: G = { let __values: [G; 3] = [__v_10, __v_4, __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_201] = [__v_12];
-                record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-            }
-          },
-        }
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_202: usize = 4;
-const IN_202: usize = 4;
-const OUT_202: usize = 1;
-fn aiur_fn_202(
-  inp: [G; IN_202],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_202], 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_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_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(0);
-        let __v_8: G = G::from_u64(0);
-        let __v_9: G = G::from_u64(0);
-        let __v_10: G = { let __values: [G; 2] = [__v_2, __v_3]; let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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 = 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 __v_14: G = { let __values: [G; 3] = [__v_9, __v_10, __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_15: G = { let __values: [G; 3] = [__v_1, __v_8, __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 __v_16: G = G::from_u64(1);
-        let __v_17: G = G::from_u64(1);
-        let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __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_7, __v_15, __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 __ret: [G; OUT_202] = [__v_19];
-        record.function_queries[202].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_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_7: G = __loaded[0];
-        let __v_8: G = __loaded[1];
-        let __v_9: G = __loaded[2];
-        match __v_7.as_canonical_u64() {
-          _ => {
-            let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_1, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { 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_10: G = __r_arr[0];
-            match __v_10.as_canonical_u64() {
-              0u64 => {
-                let __v_11: G = G::from_u64(0);
-                let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_9, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { 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_12: G = __r_arr[0];
-                let __v_13: G = { let __values: [G; 3] = [__v_7, __v_8, __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 __v_14: G = { let __values: [G; 3] = [__v_11, __v_13, __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_202] = [__v_14];
-                record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              1u64 => {
-                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 = { let __values: [G; 2] = [__v_2, __v_3]; let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_15: G = G::from_u64(1);
-                let __v_16: G = G::from_u64(1);
-                let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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_13, __v_14, __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_1, __v_12, __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_11, __v_19, __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 __ret: [G; OUT_202] = [__v_20];
-                record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              _ => {
-                let __v_11: G = G::from_u64(0);
-                let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { 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 __v_12: G = __r_arr[0];
-                let __v_13: G = { let __values: [G; 3] = [__v_11, __v_5, __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 __ret: [G; OUT_202] = [__v_13];
-                record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-            }
-          },
-        }
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_203: usize = 4;
-const IN_203: usize = 4;
-const OUT_203: usize = 1;
-fn aiur_fn_203(
-  inp: [G; IN_203],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> 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];
-    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_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_4: G = __loaded[0];
-    let __v_5: G = __loaded[1];
-    let __v_6: G = __loaded[2];
-    match __v_4.as_canonical_u64() {
-      0u64 => {
-        let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_3, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { 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_7: G = __r_arr[0];
-        let __ret: [G; OUT_203] = [__v_7];
-        record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      1u64 => {
-        let __v_7: G = G::from_u64(1);
-        let __v_8: G = (__v_2 + __v_7);
-        let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_5, __v_1, __v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { 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_9: G = __r_arr[0];
-        let __ret: [G; OUT_203] = [__v_9];
-        record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      2u64 => {
-        let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { 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_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_6, __v_1, __v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { 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_8: G = __r_arr[0];
-        let __ret: [G; OUT_203] = [__v_8];
-        record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      3u64 => {
-        let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_5, __v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { 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_7: G = __r_arr[0];
-        let __ret: [G; OUT_203] = [__v_7];
-        record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      4u64 => {
-        let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[195].get_mut(&__args[..]) { 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_7: G = __r_arr[0];
-        let __v_8: G = __r_arr[1];
-        match __v_7.as_canonical_u64() {
-          1u64 => {
-            let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_3, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { 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_9: G = __r_arr[0];
-            let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_9, __v_8, __v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { 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 __v_10: G = __r_arr[0];
-            let __ret: [G; OUT_203] = [__v_10];
-            record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          0u64 => {
-            match __v_2.as_canonical_u64() {
-              0u64 => {
-                let __ret: [G; OUT_203] = [__v_3];
-                record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              _ => {
-                let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_3, __v_1, __v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { 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 __v_9: G = __r_arr[0];
-                let __ret: [G; OUT_203] = [__v_9];
-                record.function_queries[203].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_204: usize = 5;
-const IN_204: usize = 5;
-const OUT_204: usize = 1;
-fn aiur_fn_204(
-  inp: [G; IN_204],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> 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];
-    let __v_2: G = inp[2];
-    let __v_3: G = inp[3];
-    let __v_4: G = inp[4];
-    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_5: G = __loaded[0];
-    let __v_6: G = __loaded[1];
-    let __v_7: G = __loaded[2];
-    match __v_5.as_canonical_u64() {
-      0u64 => {
-        let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_4, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { 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_8: G = __r_arr[0];
-        let __ret: [G; OUT_204] = [__v_8];
-        record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      1u64 => {
-        let __v_8: G = G::from_u64(1);
-        let __v_9: G = (__v_3 + __v_8);
-        let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { 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_10: G = __r_arr[0];
-        let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_6, __v_2, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { 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_11: G = __r_arr[0];
-        let __ret: [G; OUT_204] = [__v_11];
-        record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      2u64 => {
-        let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_0, __v_6, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { 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_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_0, __v_7, __v_2, __v_3, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { 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_9: G = __r_arr[0];
-        let __ret: [G; OUT_204] = [__v_9];
-        record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      3u64 => {
-        let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_0, __v_7, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { 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_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_6, __v_7, __v_2, __v_3, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { 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_9: G = __r_arr[0];
-        let __ret: [G; OUT_204] = [__v_9];
-        record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      4u64 => {
-        let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_6, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[195].get_mut(&__args[..]) { 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_8: G = __r_arr[0];
-        let __v_9: G = __r_arr[1];
-        match __v_8.as_canonical_u64() {
-          1u64 => {
-            let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_4, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { 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_10: G = __r_arr[0];
-            let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_10, __v_9, __v_6, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { 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 __v_11: G = __r_arr[0];
-            let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_0, __v_9, __v_3, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { 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_12: G = __r_arr[0];
-            let __ret: [G; OUT_204] = [__v_12];
-            record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          0u64 => {
-            let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_3.as_canonical_u64() {
-  0u64 => {
-    break '__mc_0 [__v_4];
-  },
-  _ => {
-    let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_4, __v_2, __v_6, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { 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 __v_10: G = __r_arr[0];
-    break '__mc_0 [__v_10];
-  },
-}
- };
-            let __v_10: G = __mc_out___mc_0[0];
-            let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_0, __v_2, __v_3, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { 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_11: G = __r_arr[0];
-            let __ret: [G; OUT_204] = [__v_11];
-            record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64()));
-          },
-        }
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-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_205], 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_205] = [__v_0];
-        record.function_queries[205].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __v_5: G = G::from_u64(0);
-        let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { 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_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { 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_7: G = __r_arr[0];
-        let __v_8: G = { let __values: [G; 3] = [__v_5, __v_6, __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_205] = [__v_8];
-        record.function_queries[205].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_206: usize = 2;
-const IN_206: usize = 2;
-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_206], 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_206] = [__v_0];
-        record.function_queries[206].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_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_5: G = __loaded[0];
-        let __v_6: G = __loaded[1];
-        let __v_7: G = __loaded[2];
-        match __v_5.as_canonical_u64() {
-          _ => {
-            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_8: G = __loaded[0];
-            let __v_9: G = __loaded[1];
-            let __v_10: G = __loaded[2];
-            match __v_8.as_canonical_u64() {
-              _ => {
-                let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_8, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[193].get_mut(&__args[..]) { 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_11: G = __r_arr[0];
-                match __v_11.as_canonical_u64() {
-                  0u64 => {
-                    let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { 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_12: G = __r_arr[0];
-                    let __ret: [G; OUT_206] = [__v_12];
-                    record.function_queries[206].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
-                  _ => {
-                    let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { 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_12: G = __r_arr[0];
-                    let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_6.as_canonical_u64() {
-  0u64 => {
-    let __v_13: G = G::from_u64(0);
-    break '__mc_0 [__v_13];
-  },
-  _ => {
-    let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_12.as_canonical_u64() {
-  1u64 => {
-    let __v_13: G = G::from_u64(1);
-    break '__mc_1 [__v_13];
-  },
-  0u64 => {
-    let __v_13: G = { let __a_val = __v_9.as_canonical_u64(); let __b_val = __v_6.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 };
-    break '__mc_1 [__v_13];
-  },
-  _ => {
-    return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64()));
-  },
-}
- };
-    let __v_13: G = __mc_out___mc_1[0];
-    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_14: G = __loaded[0];
-    let __v_15: G = __loaded[1];
-    let __v_16: G = __loaded[2];
-    let __mc_out___mc_2: [G; 1] = '__mc_2: { match __v_14.as_canonical_u64() {
-  1u64 => {
-    let __v_17: G = G::from_u64(1);
-    break '__mc_2 [__v_17];
-  },
-  0u64 => {
-    let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { 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_17: G = __r_arr[0];
-    let __v_18: G = G::from_u64(1);
+    let __v_16: G = (__v_0 * __v_8);
+    let __v_17: G = (__v_0 * __v_9);
+    let __v_18: G = (__v_1 * __v_8);
     let __v_19: G = (__v_17 + __v_18);
-    let __v_20: G = { let __a_val = __v_19.as_canonical_u64(); let __b_val = __v_6.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 };
-    break '__mc_2 [__v_20];
-  },
-  _ => {
-    return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64()));
-  },
-}
- };
-    let __v_17: G = __mc_out___mc_2[0];
-    let __v_18: G = (__v_13 * __v_17);
-    match __v_18.as_canonical_u64() {
-      0u64 => {
-        let __v_19: G = G::from_u64(0);
-        break '__mc_0 [__v_19];
-      },
-      _ => {
-        break '__mc_0 [__v_6];
-      },
-    }
-  },
-}
- };
-                    let __v_13: G = __mc_out___mc_0[0];
-                    let __mc_out___mc_3: [G; 1] = '__mc_3: { match __v_12.as_canonical_u64() {
-  1u64 => {
-    break '__mc_3 [__v_7];
-  },
-  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_14: G = __loaded[0];
-    let __v_15: G = __loaded[1];
-    let __v_16: G = __loaded[2];
-    match __v_14.as_canonical_u64() {
-      1u64 => {
-        break '__mc_3 [__v_7];
-      },
-      0u64 => {
-        let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { 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_17: G = __r_arr[0];
-        break '__mc_3 [__v_17];
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64()));
-      },
-    }
-  },
-  _ => {
-    return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64()));
-  },
-}
- };
-                    let __v_14: G = __mc_out___mc_3[0];
-                    let __v_15: G = { let __values: [G; 3] = [__v_5, __v_13, __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 __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_15, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { 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_16: G = __r_arr[0];
-                    let __ret: [G; OUT_206] = [__v_16];
-                    record.function_queries[206].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
-                }
-              },
-            }
-          },
-        }
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_207: usize = 2;
-const IN_207: usize = 2;
-const OUT_207: usize = 1;
-fn aiur_fn_207(
-  inp: [G; IN_207],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> 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 __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 __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_5: G = __loaded[0];
-        let __v_6: G = __loaded[1];
-        let __v_7: G = __loaded[2];
-        match __v_5.as_canonical_u64() {
-          1u64 => {
-            let __v_8: G = G::from_u64(1);
-            let __ret: [G; OUT_207] = [__v_8];
-            record.function_queries[207].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          0u64 => {
-            let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_207] = [__v_8];
-            record.function_queries[207].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__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_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_5: G = __loaded[0];
-        let __v_6: G = __loaded[1];
-        let __v_7: G = __loaded[2];
-        match __v_5.as_canonical_u64() {
-          1u64 => {
-            let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_207] = [__v_8];
-            record.function_queries[207].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_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_8: G = __loaded[0];
-            let __v_9: G = __loaded[1];
-            let __v_10: G = __loaded[2];
-            match __v_8.as_canonical_u64() {
-              _ => {
-                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_11: G = __loaded[0];
-                let __v_12: G = __loaded[1];
-                let __v_13: G = __loaded[2];
-                match __v_11.as_canonical_u64() {
-                  _ => {
-                    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 !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];
-                    match __v_14.as_canonical_u64() {
-                      0u64 => {
-                        let __v_15: G = (__v_9 - __v_12);
-                        match __v_15.as_canonical_u64() {
-                          0u64 => {
-                            let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_10, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[197].get_mut(&__args[..]) { 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_16: G = __r_arr[0];
-                            match __v_16.as_canonical_u64() {
-                              1u64 => {
-                                let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { 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_17: G = __r_arr[0];
-                                let __ret: [G; OUT_207] = [__v_17];
-                                record.function_queries[207].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                return Ok(__ret);
-                              },
-                              0u64 => {
-                                let __v_17: G = G::from_u64(0);
-                                let __ret: [G; OUT_207] = [__v_17];
-                                record.function_queries[207].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                return Ok(__ret);
-                              },
-                              _ => {
-                                return Err(ExecError::MatchNoCase(__v_16.as_canonical_u64()));
-                              },
-                            }
-                          },
-                          _ => {
-                            let __v_16: G = G::from_u64(0);
-                            let __ret: [G; OUT_207] = [__v_16];
-                            record.function_queries[207].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                            return Ok(__ret);
-                          },
-                        }
-                      },
-                      _ => {
-                        let __v_15: G = G::from_u64(0);
-                        let __ret: [G; OUT_207] = [__v_15];
-                        record.function_queries[207].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                        return Ok(__ret);
-                      },
-                    }
-                  },
-                }
-              },
-            }
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
-          },
-        }
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_208: usize = 3;
-const IN_208: usize = 3;
-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_208], 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(0);
-        let __ret: [G; OUT_208] = [__v_6];
-        record.function_queries[208].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_6: G = __loaded[0];
-        let __v_7: G = __loaded[1];
-        let __v_8: G = __loaded[2];
-        match __v_6.as_canonical_u64() {
-          _ => {
-            let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[193].get_mut(&__args[..]) { 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_9: G = __r_arr[0];
-            match __v_9.as_canonical_u64() {
-              0u64 => {
-                let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { 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_10: G = __r_arr[0];
-                let __ret: [G; OUT_208] = [__v_10];
-                record.function_queries[208].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              _ => {
-                let __v_10: G = { let __a_val = __v_7.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 };
-                let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_10.as_canonical_u64() {
-  0u64 => {
-    let __v_11: G = G::from_u64(1);
-    break '__mc_0 [__v_11];
-  },
-  1u64 => {
-    let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[209].get_mut(&__args[..]) { 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_11: G = __r_arr[0];
-    break '__mc_0 [__v_11];
-  },
-  _ => {
-    return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64()));
-  },
-}
- };
-                let __v_11: G = __mc_out___mc_0[0];
-                match __v_11.as_canonical_u64() {
-                  1u64 => {
-                    let __v_12: G = G::from_u64(1);
-                    let __ret: [G; OUT_208] = [__v_12];
-                    record.function_queries[208].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
-                  0u64 => {
-                    let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { 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_12: G = __r_arr[0];
-                    let __ret: [G; OUT_208] = [__v_12];
-                    record.function_queries[208].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
-                  _ => {
-                    return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64()));
-                  },
-                }
-              },
-            }
-          },
-        }
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
-      },
+    let __v_20: G = (__v_0 * __v_10);
+    let __v_21: G = (__v_1 * __v_9);
+    let __v_22: G = (__v_2 * __v_8);
+    let __v_23: G = (__v_21 + __v_22);
+    let __v_24: G = (__v_20 + __v_23);
+    let __v_25: G = (__v_0 * __v_11);
+    let __v_26: G = (__v_1 * __v_10);
+    let __v_27: G = (__v_2 * __v_9);
+    let __v_28: G = (__v_3 * __v_8);
+    let __v_29: G = (__v_27 + __v_28);
+    let __v_30: G = (__v_26 + __v_29);
+    let __v_31: G = (__v_25 + __v_30);
+    let __v_32: G = (__v_0 * __v_12);
+    let __v_33: G = (__v_1 * __v_11);
+    let __v_34: G = (__v_2 * __v_10);
+    let __v_35: G = (__v_3 * __v_9);
+    let __v_36: G = (__v_4 * __v_8);
+    let __v_37: G = (__v_35 + __v_36);
+    let __v_38: G = (__v_34 + __v_37);
+    let __v_39: G = (__v_33 + __v_38);
+    let __v_40: G = (__v_32 + __v_39);
+    let __v_41: G = (__v_0 * __v_13);
+    let __v_42: G = (__v_1 * __v_12);
+    let __v_43: G = (__v_2 * __v_11);
+    let __v_44: G = (__v_3 * __v_10);
+    let __v_45: G = (__v_4 * __v_9);
+    let __v_46: G = (__v_5 * __v_8);
+    let __v_47: G = (__v_45 + __v_46);
+    let __v_48: G = (__v_44 + __v_47);
+    let __v_49: G = (__v_43 + __v_48);
+    let __v_50: G = (__v_42 + __v_49);
+    let __v_51: G = (__v_41 + __v_50);
+    let __v_52: G = (__v_0 * __v_14);
+    let __v_53: G = (__v_1 * __v_13);
+    let __v_54: G = (__v_2 * __v_12);
+    let __v_55: G = (__v_3 * __v_11);
+    let __v_56: G = (__v_4 * __v_10);
+    let __v_57: G = (__v_5 * __v_9);
+    let __v_58: G = (__v_6 * __v_8);
+    let __v_59: G = (__v_57 + __v_58);
+    let __v_60: G = (__v_56 + __v_59);
+    let __v_61: G = (__v_55 + __v_60);
+    let __v_62: G = (__v_54 + __v_61);
+    let __v_63: G = (__v_53 + __v_62);
+    let __v_64: G = (__v_52 + __v_63);
+    let __v_65: G = (__v_0 * __v_15);
+    let __v_66: G = (__v_1 * __v_14);
+    let __v_67: G = (__v_2 * __v_13);
+    let __v_68: G = (__v_3 * __v_12);
+    let __v_69: G = (__v_4 * __v_11);
+    let __v_70: G = (__v_5 * __v_10);
+    let __v_71: G = (__v_6 * __v_9);
+    let __v_72: G = (__v_7 * __v_8);
+    let __v_73: G = (__v_71 + __v_72);
+    let __v_74: G = (__v_70 + __v_73);
+    let __v_75: G = (__v_69 + __v_74);
+    let __v_76: G = (__v_68 + __v_75);
+    let __v_77: G = (__v_67 + __v_76);
+    let __v_78: G = (__v_66 + __v_77);
+    let __v_79: G = (__v_65 + __v_78);
+    let __v_80: G = (__v_1 * __v_15);
+    let __v_81: G = (__v_2 * __v_14);
+    let __v_82: G = (__v_3 * __v_13);
+    let __v_83: G = (__v_4 * __v_12);
+    let __v_84: G = (__v_5 * __v_11);
+    let __v_85: G = (__v_6 * __v_10);
+    let __v_86: G = (__v_7 * __v_9);
+    let __v_87: G = (__v_85 + __v_86);
+    let __v_88: G = (__v_84 + __v_87);
+    let __v_89: G = (__v_83 + __v_88);
+    let __v_90: G = (__v_82 + __v_89);
+    let __v_91: G = (__v_81 + __v_90);
+    let __v_92: G = (__v_80 + __v_91);
+    let __v_93: G = (__v_2 * __v_15);
+    let __v_94: G = (__v_3 * __v_14);
+    let __v_95: G = (__v_4 * __v_13);
+    let __v_96: G = (__v_5 * __v_12);
+    let __v_97: G = (__v_6 * __v_11);
+    let __v_98: G = (__v_7 * __v_10);
+    let __v_99: G = (__v_97 + __v_98);
+    let __v_100: G = (__v_96 + __v_99);
+    let __v_101: G = (__v_95 + __v_100);
+    let __v_102: G = (__v_94 + __v_101);
+    let __v_103: G = (__v_93 + __v_102);
+    let __v_104: G = (__v_3 * __v_15);
+    let __v_105: G = (__v_4 * __v_14);
+    let __v_106: G = (__v_5 * __v_13);
+    let __v_107: G = (__v_6 * __v_12);
+    let __v_108: G = (__v_7 * __v_11);
+    let __v_109: G = (__v_107 + __v_108);
+    let __v_110: G = (__v_106 + __v_109);
+    let __v_111: G = (__v_105 + __v_110);
+    let __v_112: G = (__v_104 + __v_111);
+    let __v_113: G = (__v_4 * __v_15);
+    let __v_114: G = (__v_5 * __v_14);
+    let __v_115: G = (__v_6 * __v_13);
+    let __v_116: G = (__v_7 * __v_12);
+    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_5 * __v_15);
+    let __v_121: G = (__v_6 * __v_14);
+    let __v_122: G = (__v_7 * __v_13);
+    let __v_123: G = (__v_121 + __v_122);
+    let __v_124: G = (__v_120 + __v_123);
+    let __v_125: G = (__v_6 * __v_15);
+    let __v_126: G = (__v_7 * __v_14);
+    let __v_127: G = (__v_125 + __v_126);
+    let __v_128: G = (__v_7 * __v_15);
+    let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_16]; let __cu = true; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { 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_129: G = __r_arr[0];
+    let __v_130: G = __r_arr[1];
+    let __v_131: G = __r_arr[2];
+    let __v_132: G = G::from_u64(0);
+    let __v_133: G = if unconstrained { Bytes2::xor(&__v_129, &__v_132) } else { bytes2_xor_value(__v_129, __v_132, record) };
+    let __v_134: G = G::from_u64(0);
+    let __v_135: G = if unconstrained { Bytes2::xor(&__v_130, &__v_134) } else { bytes2_xor_value(__v_130, __v_134, record) };
+    let __v_136: G = G::from_u64(0);
+    let __v_137: G = if unconstrained { Bytes2::xor(&__v_131, &__v_136) } else { bytes2_xor_value(__v_131, __v_136, record) };
+    let __v_138: G = G::from_u64(256);
+    let __v_139: G = (__v_138 * __v_137);
+    let __v_140: G = (__v_135 + __v_139);
+    let __v_141: G = (__v_19 + __v_140);
+    let __v_142: G = G::from_u64(256);
+    let __v_143: G = (__v_142 * __v_135);
+    let __v_144: G = G::from_u64(65536);
+    let __v_145: G = (__v_144 * __v_137);
+    let __v_146: G = (__v_143 + __v_145);
+    let __v_147: G = (__v_133 + __v_146);
+    if (__v_16 != __v_147) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_147.as_canonical_u64(), msg: Some("u64_mul column 0: split_carry hint does not recompose to the column sum".to_string()) });
     }
-  })
-}
-
-const INPUT_SIZE_209: usize = 2;
-const IN_209: usize = 2;
-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_209], 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_209] = [__v_5];
-        record.function_queries[209].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; 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: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
-        let __v_5: G = __loaded[0];
-        let __v_6: G = __loaded[1];
-        match __v_5.as_canonical_u64() {
-          _ => {
-            let __v_7: G = G::from_u64(1);
-            let __v_8: G = (__v_6 + __v_7);
-            let __v_9: G = { let __a_val = __v_8.as_canonical_u64(); let __b_val = __v_1.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_9.as_canonical_u64() {
-              0u64 => {
-                let __v_10: G = G::from_u64(1);
-                let __ret: [G; OUT_209] = [__v_10];
-                record.function_queries[209].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              1u64 => {
-                let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[209].get_mut(&__args[..]) { 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_10: G = __r_arr[0];
-                let __ret: [G; OUT_209] = [__v_10];
-                record.function_queries[209].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              _ => {
-                return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64()));
-              },
-            }
-          },
-        }
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
+    let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_141]; let __cu = true; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { 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_148: G = __r_arr[0];
+    let __v_149: G = __r_arr[1];
+    let __v_150: G = __r_arr[2];
+    let __v_151: G = G::from_u64(0);
+    let __v_152: G = if unconstrained { Bytes2::xor(&__v_148, &__v_151) } else { bytes2_xor_value(__v_148, __v_151, record) };
+    let __v_153: G = G::from_u64(0);
+    let __v_154: G = if unconstrained { Bytes2::xor(&__v_149, &__v_153) } else { bytes2_xor_value(__v_149, __v_153, record) };
+    let __v_155: G = G::from_u64(0);
+    let __v_156: G = if unconstrained { Bytes2::xor(&__v_150, &__v_155) } else { bytes2_xor_value(__v_150, __v_155, record) };
+    let __v_157: G = G::from_u64(256);
+    let __v_158: G = (__v_157 * __v_156);
+    let __v_159: G = (__v_154 + __v_158);
+    let __v_160: G = (__v_24 + __v_159);
+    let __v_161: G = G::from_u64(256);
+    let __v_162: G = (__v_161 * __v_154);
+    let __v_163: G = G::from_u64(65536);
+    let __v_164: G = (__v_163 * __v_156);
+    let __v_165: G = (__v_162 + __v_164);
+    let __v_166: G = (__v_152 + __v_165);
+    if (__v_141 != __v_166) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_141.as_canonical_u64(), rhs: __v_166.as_canonical_u64(), msg: Some("u64_mul column 1: split_carry hint does not recompose to the column sum".to_string()) });
     }
-  })
-}
-
-const INPUT_SIZE_210: usize = 4;
-const IN_210: usize = 4;
-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_210], 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_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_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(0);
-        let __ret: [G; OUT_210] = [__v_7];
-        record.function_queries[210].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_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_7: G = __loaded[0];
-        let __v_8: G = __loaded[1];
-        let __v_9: G = __loaded[2];
-        match __v_7.as_canonical_u64() {
-          _ => {
-            let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[193].get_mut(&__args[..]) { 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_10: G = __r_arr[0];
-            match __v_10.as_canonical_u64() {
-              0u64 => {
-                let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[210].get_mut(&__args[..]) { 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_11: G = __r_arr[0];
-                let __ret: [G; OUT_210] = [__v_11];
-                record.function_queries[210].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              _ => {
-                let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_9, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[211].get_mut(&__args[..]) { 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_11: G = __r_arr[0];
-                match __v_11.as_canonical_u64() {
-                  1u64 => {
-                    let __v_12: G = G::from_u64(1);
-                    let __ret: [G; OUT_210] = [__v_12];
-                    record.function_queries[210].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
-                  0u64 => {
-                    let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[210].get_mut(&__args[..]) { 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_12: G = __r_arr[0];
-                    let __ret: [G; OUT_210] = [__v_12];
-                    record.function_queries[210].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
-                  _ => {
-                    return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64()));
-                  },
-                }
-              },
-            }
-          },
-        }
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
-      },
+    let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_160]; let __cu = true; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { 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_167: G = __r_arr[0];
+    let __v_168: G = __r_arr[1];
+    let __v_169: G = __r_arr[2];
+    let __v_170: G = G::from_u64(0);
+    let __v_171: G = if unconstrained { Bytes2::xor(&__v_167, &__v_170) } else { bytes2_xor_value(__v_167, __v_170, record) };
+    let __v_172: G = G::from_u64(0);
+    let __v_173: G = if unconstrained { Bytes2::xor(&__v_168, &__v_172) } else { bytes2_xor_value(__v_168, __v_172, record) };
+    let __v_174: G = G::from_u64(0);
+    let __v_175: G = if unconstrained { Bytes2::xor(&__v_169, &__v_174) } else { bytes2_xor_value(__v_169, __v_174, record) };
+    let __v_176: G = G::from_u64(256);
+    let __v_177: G = (__v_176 * __v_175);
+    let __v_178: G = (__v_173 + __v_177);
+    let __v_179: G = (__v_31 + __v_178);
+    let __v_180: G = G::from_u64(256);
+    let __v_181: G = (__v_180 * __v_173);
+    let __v_182: G = G::from_u64(65536);
+    let __v_183: G = (__v_182 * __v_175);
+    let __v_184: G = (__v_181 + __v_183);
+    let __v_185: G = (__v_171 + __v_184);
+    if (__v_160 != __v_185) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_160.as_canonical_u64(), rhs: __v_185.as_canonical_u64(), msg: Some("u64_mul column 2: split_carry hint does not recompose to the column sum".to_string()) });
     }
-  })
-}
-
-const INPUT_SIZE_211: usize = 3;
-const IN_211: usize = 3;
-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_211], 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(0);
-        let __ret: [G; OUT_211] = [__v_6];
-        record.function_queries[211].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; 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: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
-        let __v_6: G = __loaded[0];
-        let __v_7: G = __loaded[1];
-        match __v_6.as_canonical_u64() {
-          _ => {
-            let __v_8: G = (__v_6 - __v_1);
-            match __v_8.as_canonical_u64() {
-              0u64 => {
-                let __v_9: G = { let __a_val = __v_7.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_9.as_canonical_u64() {
-                  0u64 => {
-                    let __v_10: G = G::from_u64(1);
-                    let __ret: [G; OUT_211] = [__v_10];
-                    record.function_queries[211].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
-                  1u64 => {
-                    let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[211].get_mut(&__args[..]) { 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_10: G = __r_arr[0];
-                    let __ret: [G; OUT_211] = [__v_10];
-                    record.function_queries[211].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
-                  _ => {
-                    return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64()));
-                  },
-                }
-              },
-              _ => {
-                let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[211].get_mut(&__args[..]) { 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_9: G = __r_arr[0];
-                let __ret: [G; OUT_211] = [__v_9];
-                record.function_queries[211].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-            }
-          },
-        }
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
-      },
+    let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_179]; let __cu = true; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { 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_186: G = __r_arr[0];
+    let __v_187: G = __r_arr[1];
+    let __v_188: G = __r_arr[2];
+    let __v_189: G = G::from_u64(0);
+    let __v_190: G = if unconstrained { Bytes2::xor(&__v_186, &__v_189) } else { bytes2_xor_value(__v_186, __v_189, record) };
+    let __v_191: G = G::from_u64(0);
+    let __v_192: G = if unconstrained { Bytes2::xor(&__v_187, &__v_191) } else { bytes2_xor_value(__v_187, __v_191, record) };
+    let __v_193: G = G::from_u64(0);
+    let __v_194: G = if unconstrained { Bytes2::xor(&__v_188, &__v_193) } else { bytes2_xor_value(__v_188, __v_193, record) };
+    let __v_195: G = G::from_u64(256);
+    let __v_196: G = (__v_195 * __v_194);
+    let __v_197: G = (__v_192 + __v_196);
+    let __v_198: G = (__v_40 + __v_197);
+    let __v_199: G = G::from_u64(256);
+    let __v_200: G = (__v_199 * __v_192);
+    let __v_201: G = G::from_u64(65536);
+    let __v_202: G = (__v_201 * __v_194);
+    let __v_203: G = (__v_200 + __v_202);
+    let __v_204: G = (__v_190 + __v_203);
+    if (__v_179 != __v_204) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_179.as_canonical_u64(), rhs: __v_204.as_canonical_u64(), msg: Some("u64_mul column 3: split_carry hint does not recompose to the column sum".to_string()) });
     }
-  })
-}
-
-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_212], 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(1);
-        let __ret: [G; OUT_212] = [__v_5];
-        record.function_queries[212].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_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_5: G = __loaded[0];
-        let __v_6: G = __loaded[1];
-        let __v_7: G = __loaded[2];
-        match __v_5.as_canonical_u64() {
-          _ => {
-            let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_6.as_canonical_u64() {
-  0u64 => {
-    let __v_8: G = G::from_u64(1);
-    break '__mc_0 [__v_8];
-  },
-  _ => {
-    let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_1, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { 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_8: G = __r_arr[0];
-    break '__mc_0 [__v_8];
-  },
-}
- };
-            let __v_8: G = __mc_out___mc_0[0];
-            match __v_8.as_canonical_u64() {
-              0u64 => {
-                let __v_9: G = G::from_u64(0);
-                let __ret: [G; OUT_212] = [__v_9];
-                record.function_queries[212].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              1u64 => {
-                let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_7, __v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { 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_9: G = __r_arr[0];
-                match __v_9.as_canonical_u64() {
-                  0u64 => {
-                    let __v_10: G = G::from_u64(0);
-                    let __ret: [G; OUT_212] = [__v_10];
-                    record.function_queries[212].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
-                  1u64 => {
-                    let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[212].get_mut(&__args[..]) { 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_10: G = __r_arr[0];
-                    let __ret: [G; OUT_212] = [__v_10];
-                    record.function_queries[212].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
-                  _ => {
-                    return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64()));
-                  },
-                }
-              },
-              _ => {
-                return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64()));
-              },
-            }
-          },
-        }
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
+    let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_198]; let __cu = true; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { 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_205: G = __r_arr[0];
+    let __v_206: G = __r_arr[1];
+    let __v_207: G = __r_arr[2];
+    let __v_208: G = G::from_u64(0);
+    let __v_209: G = if unconstrained { Bytes2::xor(&__v_205, &__v_208) } else { bytes2_xor_value(__v_205, __v_208, record) };
+    let __v_210: G = G::from_u64(0);
+    let __v_211: G = if unconstrained { Bytes2::xor(&__v_206, &__v_210) } else { bytes2_xor_value(__v_206, __v_210, record) };
+    let __v_212: G = G::from_u64(0);
+    let __v_213: G = if unconstrained { Bytes2::xor(&__v_207, &__v_212) } else { bytes2_xor_value(__v_207, __v_212, record) };
+    let __v_214: G = G::from_u64(256);
+    let __v_215: G = (__v_214 * __v_213);
+    let __v_216: G = (__v_211 + __v_215);
+    let __v_217: G = (__v_51 + __v_216);
+    let __v_218: G = G::from_u64(256);
+    let __v_219: G = (__v_218 * __v_211);
+    let __v_220: G = G::from_u64(65536);
+    let __v_221: G = (__v_220 * __v_213);
+    let __v_222: G = (__v_219 + __v_221);
+    let __v_223: G = (__v_209 + __v_222);
+    if (__v_198 != __v_223) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_198.as_canonical_u64(), rhs: __v_223.as_canonical_u64(), msg: Some("u64_mul column 4: split_carry hint does not recompose to the column sum".to_string()) });
     }
-  })
-}
-
-const INPUT_SIZE_213: usize = 3;
-const IN_213: usize = 3;
-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_213], 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 __ret: [G; OUT_213] = [__v_6];
-        record.function_queries[213].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; 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: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
-        let __v_6: G = __loaded[0];
-        let __v_7: G = __loaded[1];
-        match __v_6.as_canonical_u64() {
-          _ => {
-            let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_1, __v_2, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[210].get_mut(&__args[..]) { 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_8: G = __r_arr[0];
-            match __v_8.as_canonical_u64() {
-              0u64 => {
-                let __v_9: G = G::from_u64(0);
-                let __ret: [G; OUT_213] = [__v_9];
-                record.function_queries[213].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              1u64 => {
-                let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { 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_9: G = __r_arr[0];
-                let __ret: [G; OUT_213] = [__v_9];
-                record.function_queries[213].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              _ => {
-                return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64()));
-              },
-            }
-          },
-        }
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
-      },
+    let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_217]; let __cu = true; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { 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_224: G = __r_arr[0];
+    let __v_225: G = __r_arr[1];
+    let __v_226: G = __r_arr[2];
+    let __v_227: G = G::from_u64(0);
+    let __v_228: G = if unconstrained { Bytes2::xor(&__v_224, &__v_227) } else { bytes2_xor_value(__v_224, __v_227, record) };
+    let __v_229: G = G::from_u64(0);
+    let __v_230: G = if unconstrained { Bytes2::xor(&__v_225, &__v_229) } else { bytes2_xor_value(__v_225, __v_229, record) };
+    let __v_231: G = G::from_u64(0);
+    let __v_232: G = if unconstrained { Bytes2::xor(&__v_226, &__v_231) } else { bytes2_xor_value(__v_226, __v_231, record) };
+    let __v_233: G = G::from_u64(256);
+    let __v_234: G = (__v_233 * __v_232);
+    let __v_235: G = (__v_230 + __v_234);
+    let __v_236: G = (__v_64 + __v_235);
+    let __v_237: G = G::from_u64(256);
+    let __v_238: G = (__v_237 * __v_230);
+    let __v_239: G = G::from_u64(65536);
+    let __v_240: G = (__v_239 * __v_232);
+    let __v_241: G = (__v_238 + __v_240);
+    let __v_242: G = (__v_228 + __v_241);
+    if (__v_217 != __v_242) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_217.as_canonical_u64(), rhs: __v_242.as_canonical_u64(), msg: Some("u64_mul column 5: split_carry hint does not recompose to the column sum".to_string()) });
     }
-  })
-}
-
-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_214], 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(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 __v_5: G = G::from_u64(0);
-    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 __v_9: G = { let __values: [G; 3] = [__v_4, __v_5, __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_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 __v_13: G = { let __values: [G; 3] = [__v_1, __v_9, __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 __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 __v_17: G = G::from_u64(0);
-    let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_0, __v_16, __v_17, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { 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_18: G = __r_arr[0];
-    let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_18, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { 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 __ret: [G; OUT_214] = [__v_19];
-    record.function_queries[214].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_215: usize = 2;
-const IN_215: usize = 2;
-const OUT_215: usize = 1;
-fn aiur_fn_215(
-  inp: [G; IN_215],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> 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_191] = { let __args: [G; IN_191] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[191].get_mut(&__args[..]) { 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_2: G = __r_arr[0];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
-        let __v_3: G = G::from_u64(1);
-        let __ret: [G; OUT_215] = [__v_3];
-        record.function_queries[215].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_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() {
-          0u64 => {
-            let __v_6: G = G::from_u64(1);
-            let __ret: [G; OUT_215] = [__v_6];
-            record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { 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_6: G = __r_arr[0];
-            let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { 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_7: G = __r_arr[0];
-            let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[212].get_mut(&__args[..]) { 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_8: G = __r_arr[0];
-            let __ret: [G; OUT_215] = [__v_8];
-            record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-        }
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
+    let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_236]; let __cu = true; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { 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_243: G = __r_arr[0];
+    let __v_244: G = __r_arr[1];
+    let __v_245: G = __r_arr[2];
+    let __v_246: G = G::from_u64(0);
+    let __v_247: G = if unconstrained { Bytes2::xor(&__v_243, &__v_246) } else { bytes2_xor_value(__v_243, __v_246, record) };
+    let __v_248: G = G::from_u64(0);
+    let __v_249: G = if unconstrained { Bytes2::xor(&__v_244, &__v_248) } else { bytes2_xor_value(__v_244, __v_248, record) };
+    let __v_250: G = G::from_u64(0);
+    let __v_251: G = if unconstrained { Bytes2::xor(&__v_245, &__v_250) } else { bytes2_xor_value(__v_245, __v_250, record) };
+    let __v_252: G = G::from_u64(256);
+    let __v_253: G = (__v_252 * __v_251);
+    let __v_254: G = (__v_249 + __v_253);
+    let __v_255: G = (__v_79 + __v_254);
+    let __v_256: G = G::from_u64(256);
+    let __v_257: G = (__v_256 * __v_249);
+    let __v_258: G = G::from_u64(65536);
+    let __v_259: G = (__v_258 * __v_251);
+    let __v_260: G = (__v_257 + __v_259);
+    let __v_261: G = (__v_247 + __v_260);
+    if (__v_236 != __v_261) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_236.as_canonical_u64(), rhs: __v_261.as_canonical_u64(), msg: Some("u64_mul column 6: split_carry hint does not recompose to the column sum".to_string()) });
+    }
+    let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_255]; let __cu = true; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { 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_262: G = __r_arr[0];
+    let __v_263: G = __r_arr[1];
+    let __v_264: G = __r_arr[2];
+    let __v_265: G = G::from_u64(0);
+    let __v_266: G = if unconstrained { Bytes2::xor(&__v_262, &__v_265) } else { bytes2_xor_value(__v_262, __v_265, record) };
+    let __v_267: G = G::from_u64(0);
+    let __v_268: G = if unconstrained { Bytes2::xor(&__v_263, &__v_267) } else { bytes2_xor_value(__v_263, __v_267, record) };
+    let __v_269: G = G::from_u64(0);
+    let __v_270: G = if unconstrained { Bytes2::xor(&__v_264, &__v_269) } else { bytes2_xor_value(__v_264, __v_269, record) };
+    let __v_271: G = G::from_u64(256);
+    let __v_272: G = (__v_271 * __v_270);
+    let __v_273: G = (__v_268 + __v_272);
+    let __v_274: G = (__v_92 + __v_273);
+    let __v_275: G = G::from_u64(256);
+    let __v_276: G = (__v_275 * __v_268);
+    let __v_277: G = G::from_u64(65536);
+    let __v_278: G = (__v_277 * __v_270);
+    let __v_279: G = (__v_276 + __v_278);
+    let __v_280: G = (__v_266 + __v_279);
+    if (__v_255 != __v_280) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_255.as_canonical_u64(), rhs: __v_280.as_canonical_u64(), msg: Some("u64_mul column 7: split_carry hint does not recompose to the column sum".to_string()) });
     }
-  })
-}
-
-const INPUT_SIZE_216: usize = 2;
-const IN_216: usize = 2;
-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_216], 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_191] = { let __args: [G; IN_191] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[191].get_mut(&__args[..]) { 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_2: G = __r_arr[0];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
-        let __v_3: G = G::from_u64(1);
-        let __ret: [G; OUT_216] = [__v_3];
-        record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { 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_3: G = __r_arr[0];
-        let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { 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_4: G = __r_arr[0];
-        let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { 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 __ret: [G; OUT_216] = [__v_5];
-        record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
+    let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_274]; let __cu = true; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { 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_281: G = __r_arr[0];
+    let __v_282: G = __r_arr[1];
+    let __v_283: G = __r_arr[2];
+    let __v_284: G = G::from_u64(0);
+    let __v_285: G = if unconstrained { Bytes2::xor(&__v_281, &__v_284) } else { bytes2_xor_value(__v_281, __v_284, record) };
+    let __v_286: G = G::from_u64(0);
+    let __v_287: G = if unconstrained { Bytes2::xor(&__v_282, &__v_286) } else { bytes2_xor_value(__v_282, __v_286, record) };
+    let __v_288: G = G::from_u64(0);
+    let __v_289: G = if unconstrained { Bytes2::xor(&__v_283, &__v_288) } else { bytes2_xor_value(__v_283, __v_288, record) };
+    let __v_290: G = G::from_u64(256);
+    let __v_291: G = (__v_290 * __v_289);
+    let __v_292: G = (__v_287 + __v_291);
+    let __v_293: G = (__v_103 + __v_292);
+    let __v_294: G = G::from_u64(256);
+    let __v_295: G = (__v_294 * __v_287);
+    let __v_296: G = G::from_u64(65536);
+    let __v_297: G = (__v_296 * __v_289);
+    let __v_298: G = (__v_295 + __v_297);
+    let __v_299: G = (__v_285 + __v_298);
+    if (__v_274 != __v_299) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_274.as_canonical_u64(), rhs: __v_299.as_canonical_u64(), msg: Some("u64_mul column 8: split_carry hint does not recompose to the column sum".to_string()) });
     }
-  })
-}
-
-const INPUT_SIZE_217: usize = 2;
-const IN_217: usize = 2;
-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_217], 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_222] = { let __args: [G; IN_222] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[222].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_222] = unsafe { *(result.output.as_ptr() as *const [G; OUT_222]) }; __ret } else { aiur_fn_222(__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() {
-      1u64 => {
-        let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[222].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_222] = unsafe { *(result.output.as_ptr() as *const [G; OUT_222]) }; __ret } else { aiur_fn_222(__args, record, io_buffer, __cu)? } };
-        let __v_4: G = __r_arr[0];
-        let __v_5: G = __r_arr[1];
-        match __v_4.as_canonical_u64() {
-          1u64 => {
-            let __v_6: G = { let __a_val = __v_3.as_canonical_u64(); let __b_val = __v_5.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_6.as_canonical_u64() {
-              1u64 => {
-                let __ret: [G; OUT_217] = [__v_1];
-                record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              0u64 => {
-                let __ret: [G; OUT_217] = [__v_0];
-                record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              _ => {
-                return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64()));
-              },
-            }
-          },
-          _ => {
-            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 !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_6: G = __r_arr[0];
-            let __ret: [G; OUT_217] = [__v_6];
-            record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-        }
-      },
-      _ => {
-        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 !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 __ret: [G; OUT_217] = [__v_4];
-        record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
+    let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_293]; let __cu = true; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { 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_300: G = __r_arr[0];
+    let __v_301: G = __r_arr[1];
+    let __v_302: G = __r_arr[2];
+    let __v_303: G = G::from_u64(0);
+    let __v_304: G = if unconstrained { Bytes2::xor(&__v_300, &__v_303) } else { bytes2_xor_value(__v_300, __v_303, record) };
+    let __v_305: G = G::from_u64(0);
+    let __v_306: G = if unconstrained { Bytes2::xor(&__v_301, &__v_305) } else { bytes2_xor_value(__v_301, __v_305, record) };
+    let __v_307: G = G::from_u64(0);
+    let __v_308: G = if unconstrained { Bytes2::xor(&__v_302, &__v_307) } else { bytes2_xor_value(__v_302, __v_307, record) };
+    let __v_309: G = G::from_u64(256);
+    let __v_310: G = (__v_309 * __v_308);
+    let __v_311: G = (__v_306 + __v_310);
+    let __v_312: G = (__v_112 + __v_311);
+    let __v_313: G = G::from_u64(256);
+    let __v_314: G = (__v_313 * __v_306);
+    let __v_315: G = G::from_u64(65536);
+    let __v_316: G = (__v_315 * __v_308);
+    let __v_317: G = (__v_314 + __v_316);
+    let __v_318: G = (__v_304 + __v_317);
+    if (__v_293 != __v_318) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_293.as_canonical_u64(), rhs: __v_318.as_canonical_u64(), msg: Some("u64_mul column 9: split_carry hint does not recompose to the column sum".to_string()) });
     }
-  })
-}
-
-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_218], 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_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 !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];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
-        let __ret: [G; OUT_218] = [__v_0];
-        record.function_queries[218].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_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() {
-          0u64 => {
-            let __ret: [G; OUT_218] = [__v_1];
-            record.function_queries[218].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_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 __ret: [G; OUT_218] = [__v_0];
-                record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              _ => {
-                let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_1, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[220].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_220] = unsafe { *(result.output.as_ptr() as *const [G; OUT_220]) }; __ret } else { aiur_fn_220(__args, record, io_buffer, __cu)? } };
-                let __v_9: G = __r_arr[0];
-                match __v_9.as_canonical_u64() {
-                  1u64 => {
-                    let __ret: [G; OUT_218] = [__v_1];
-                    record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
-                  0u64 => {
-                    let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[220].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_220] = unsafe { *(result.output.as_ptr() as *const [G; OUT_220]) }; __ret } else { aiur_fn_220(__args, record, io_buffer, __cu)? } };
-                    let __v_10: G = __r_arr[0];
-                    match __v_10.as_canonical_u64() {
-                      1u64 => {
-                        let __ret: [G; OUT_218] = [__v_0];
-                        record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                        return Ok(__ret);
-                      },
-                      0u64 => {
-                        let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[221].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_221] = unsafe { *(result.output.as_ptr() as *const [G; OUT_221]) }; __ret } else { aiur_fn_221(__args, record, io_buffer, __cu)? } };
-                        let __v_11: G = __r_arr[0];
-                        let __ret: [G; OUT_218] = [__v_11];
-                        record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                        return Ok(__ret);
-                      },
-                      _ => {
-                        return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64()));
-                      },
-                    }
-                  },
-                  _ => {
-                    return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64()));
-                  },
-                }
-              },
-            }
-          },
-        }
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
+    let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_312]; let __cu = true; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { 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_319: G = __r_arr[0];
+    let __v_320: G = __r_arr[1];
+    let __v_321: G = __r_arr[2];
+    let __v_322: G = G::from_u64(0);
+    let __v_323: G = if unconstrained { Bytes2::xor(&__v_319, &__v_322) } else { bytes2_xor_value(__v_319, __v_322, record) };
+    let __v_324: G = G::from_u64(0);
+    let __v_325: G = if unconstrained { Bytes2::xor(&__v_320, &__v_324) } else { bytes2_xor_value(__v_320, __v_324, record) };
+    let __v_326: G = G::from_u64(0);
+    let __v_327: G = if unconstrained { Bytes2::xor(&__v_321, &__v_326) } else { bytes2_xor_value(__v_321, __v_326, record) };
+    let __v_328: G = G::from_u64(256);
+    let __v_329: G = (__v_328 * __v_327);
+    let __v_330: G = (__v_325 + __v_329);
+    let __v_331: G = (__v_119 + __v_330);
+    let __v_332: G = G::from_u64(256);
+    let __v_333: G = (__v_332 * __v_325);
+    let __v_334: G = G::from_u64(65536);
+    let __v_335: G = (__v_334 * __v_327);
+    let __v_336: G = (__v_333 + __v_335);
+    let __v_337: G = (__v_323 + __v_336);
+    if (__v_312 != __v_337) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_312.as_canonical_u64(), rhs: __v_337.as_canonical_u64(), msg: Some("u64_mul column 10: split_carry hint does not recompose to the column sum".to_string()) });
     }
-  })
-}
-
-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_219], 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);
-    match __v_2.as_canonical_u64() {
-      0u64 => {
-        let __v_3: G = G::from_u64(1);
-        let __ret: [G; OUT_219] = [__v_3];
-        record.function_queries[219].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_3: G = __loaded[0];
-        let __v_4: G = __loaded[1];
-        let __v_5: G = __loaded[2];
-        match __v_3.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_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 = G::from_u64(1);
-                let __ret: [G; OUT_219] = [__v_9];
-                record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              _ => {
-                let __v_9: G = G::from_u64(0);
-                let __ret: [G; OUT_219] = [__v_9];
-                record.function_queries[219].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_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_219] = { let __args: [G; IN_219] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[219].get_mut(&__args[..]) { 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_9: G = __r_arr[0];
-                let __ret: [G; OUT_219] = [__v_9];
-                record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              _ => {
-                let __v_9: G = G::from_u64(0);
-                let __ret: [G; OUT_219] = [__v_9];
-                record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-            }
-          },
-          2u64 => {
-            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() {
-              2u64 => {
-                let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[219].get_mut(&__args[..]) { 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_9: G = __r_arr[0];
-                let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[219].get_mut(&__args[..]) { 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_10: G = __r_arr[0];
-                let __v_11: G = (__v_9 * __v_10);
-                let __ret: [G; OUT_219] = [__v_11];
-                record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              _ => {
-                let __v_9: G = G::from_u64(0);
-                let __ret: [G; OUT_219] = [__v_9];
-                record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-            }
-          },
-          3u64 => {
-            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() {
-              3u64 => {
-                let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[219].get_mut(&__args[..]) { 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_9: G = __r_arr[0];
-                let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[219].get_mut(&__args[..]) { 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_10: G = __r_arr[0];
-                let __v_11: G = (__v_9 * __v_10);
-                let __ret: [G; OUT_219] = [__v_11];
-                record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              _ => {
-                let __v_9: G = G::from_u64(0);
-                let __ret: [G; OUT_219] = [__v_9];
-                record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-            }
-          },
-          4u64 => {
-            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() {
-              4u64 => {
-                let __v_9: G = (__v_4 - __v_7);
-                match __v_9.as_canonical_u64() {
-                  0u64 => {
-                    let __v_10: G = G::from_u64(1);
-                    let __ret: [G; OUT_219] = [__v_10];
-                    record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
-                  _ => {
-                    let __v_10: G = G::from_u64(0);
-                    let __ret: [G; OUT_219] = [__v_10];
-                    record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
-                }
-              },
-              _ => {
-                let __v_9: G = G::from_u64(0);
-                let __ret: [G; OUT_219] = [__v_9];
-                record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-            }
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
-          },
-        }
-      },
+    let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_331]; let __cu = true; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { 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_338: G = __r_arr[0];
+    let __v_339: G = __r_arr[1];
+    let __v_340: G = __r_arr[2];
+    let __v_341: G = G::from_u64(0);
+    let __v_342: G = if unconstrained { Bytes2::xor(&__v_338, &__v_341) } else { bytes2_xor_value(__v_338, __v_341, record) };
+    let __v_343: G = G::from_u64(0);
+    let __v_344: G = if unconstrained { Bytes2::xor(&__v_339, &__v_343) } else { bytes2_xor_value(__v_339, __v_343, record) };
+    let __v_345: G = G::from_u64(0);
+    let __v_346: G = if unconstrained { Bytes2::xor(&__v_340, &__v_345) } else { bytes2_xor_value(__v_340, __v_345, record) };
+    let __v_347: G = G::from_u64(256);
+    let __v_348: G = (__v_347 * __v_346);
+    let __v_349: G = (__v_344 + __v_348);
+    let __v_350: G = (__v_124 + __v_349);
+    let __v_351: G = G::from_u64(256);
+    let __v_352: G = (__v_351 * __v_344);
+    let __v_353: G = G::from_u64(65536);
+    let __v_354: G = (__v_353 * __v_346);
+    let __v_355: G = (__v_352 + __v_354);
+    let __v_356: G = (__v_342 + __v_355);
+    if (__v_331 != __v_356) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_331.as_canonical_u64(), rhs: __v_356.as_canonical_u64(), msg: Some("u64_mul column 11: split_carry hint does not recompose to the column sum".to_string()) });
     }
-  })
-}
-
-const INPUT_SIZE_220: usize = 2;
-const IN_220: usize = 2;
-const OUT_220: usize = 1;
-fn aiur_fn_220(
-  inp: [G; IN_220],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_220], 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() {
-      2u64 => {
-        let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[219].get_mut(&__args[..]) { 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_5: G = __r_arr[0];
-        match __v_5.as_canonical_u64() {
-          1u64 => {
-            let __v_6: G = G::from_u64(1);
-            let __ret: [G; OUT_220] = [__v_6];
-            record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          0u64 => {
-            let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[219].get_mut(&__args[..]) { 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_6: G = __r_arr[0];
-            let __ret: [G; OUT_220] = [__v_6];
-            record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
-          },
-        }
-      },
-      _ => {
-        let __v_5: G = G::from_u64(0);
-        let __ret: [G; OUT_220] = [__v_5];
-        record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
+    let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_350]; let __cu = true; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { 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_357: G = __r_arr[0];
+    let __v_358: G = __r_arr[1];
+    let __v_359: G = __r_arr[2];
+    let __v_360: G = G::from_u64(0);
+    let __v_361: G = if unconstrained { Bytes2::xor(&__v_357, &__v_360) } else { bytes2_xor_value(__v_357, __v_360, record) };
+    let __v_362: G = G::from_u64(0);
+    let __v_363: G = if unconstrained { Bytes2::xor(&__v_358, &__v_362) } else { bytes2_xor_value(__v_358, __v_362, record) };
+    let __v_364: G = G::from_u64(0);
+    let __v_365: G = if unconstrained { Bytes2::xor(&__v_359, &__v_364) } else { bytes2_xor_value(__v_359, __v_364, record) };
+    let __v_366: G = G::from_u64(256);
+    let __v_367: G = (__v_366 * __v_365);
+    let __v_368: G = (__v_363 + __v_367);
+    let __v_369: G = (__v_127 + __v_368);
+    let __v_370: G = G::from_u64(256);
+    let __v_371: G = (__v_370 * __v_363);
+    let __v_372: G = G::from_u64(65536);
+    let __v_373: G = (__v_372 * __v_365);
+    let __v_374: G = (__v_371 + __v_373);
+    let __v_375: G = (__v_361 + __v_374);
+    if (__v_350 != __v_375) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_350.as_canonical_u64(), rhs: __v_375.as_canonical_u64(), msg: Some("u64_mul column 12: split_carry hint does not recompose to the column sum".to_string()) });
     }
-  })
-}
-
-const INPUT_SIZE_221: usize = 2;
-const IN_221: usize = 2;
-const OUT_221: usize = 1;
-fn aiur_fn_221(
-  inp: [G; IN_221],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_221], 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(0);
-    let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[223].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_223] = unsafe { *(result.output.as_ptr() as *const [G; OUT_223]) }; __ret } else { aiur_fn_223(__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(0);
-    let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[223].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_223] = unsafe { *(result.output.as_ptr() as *const [G; OUT_223]) }; __ret } else { aiur_fn_223(__args, record, io_buffer, __cu)? } };
-    let __v_6: G = __r_arr[0];
-    let __v_7: G = __r_arr[1];
-    let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[219].get_mut(&__args[..]) { 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_8: G = __r_arr[0];
-    match __v_8.as_canonical_u64() {
-      1u64 => {
-        let __v_9: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_7.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_9.as_canonical_u64() {
-          1u64 => {
-            let __ret: [G; OUT_221] = [__v_1];
-            record.function_queries[221].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          0u64 => {
-            let __ret: [G; OUT_221] = [__v_0];
-            record.function_queries[221].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64()));
-          },
-        }
-      },
-      0u64 => {
-        let __v_9: G = G::from_u64(2);
-        let __v_10: G = { let __values: [G; 3] = [__v_9, __v_0, __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_221] = [__v_10];
-        record.function_queries[221].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64()));
-      },
+    let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_369]; let __cu = true; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { 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_376: G = __r_arr[0];
+    let __v_377: G = __r_arr[1];
+    let __v_378: G = __r_arr[2];
+    let __v_379: G = G::from_u64(0);
+    let __v_380: G = if unconstrained { Bytes2::xor(&__v_376, &__v_379) } else { bytes2_xor_value(__v_376, __v_379, record) };
+    let __v_381: G = G::from_u64(0);
+    let __v_382: G = if unconstrained { Bytes2::xor(&__v_377, &__v_381) } else { bytes2_xor_value(__v_377, __v_381, record) };
+    let __v_383: G = G::from_u64(0);
+    let __v_384: G = if unconstrained { Bytes2::xor(&__v_378, &__v_383) } else { bytes2_xor_value(__v_378, __v_383, record) };
+    let __v_385: G = G::from_u64(256);
+    let __v_386: G = (__v_385 * __v_384);
+    let __v_387: G = (__v_382 + __v_386);
+    let __v_388: G = (__v_128 + __v_387);
+    let __v_389: G = G::from_u64(256);
+    let __v_390: G = (__v_389 * __v_382);
+    let __v_391: G = G::from_u64(65536);
+    let __v_392: G = (__v_391 * __v_384);
+    let __v_393: G = (__v_390 + __v_392);
+    let __v_394: G = (__v_380 + __v_393);
+    if (__v_369 != __v_394) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_369.as_canonical_u64(), rhs: __v_394.as_canonical_u64(), msg: Some("u64_mul column 13: split_carry hint does not recompose to the column sum".to_string()) });
+    }
+    let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_388]; let __cu = true; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { 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_395: G = __r_arr[0];
+    let __v_396: G = __r_arr[1];
+    let __v_397: G = __r_arr[2];
+    let __v_398: G = G::from_u64(0);
+    let __v_399: G = if unconstrained { Bytes2::xor(&__v_395, &__v_398) } else { bytes2_xor_value(__v_395, __v_398, record) };
+    let __v_400: G = G::from_u64(0);
+    let __v_401: G = if unconstrained { Bytes2::xor(&__v_396, &__v_400) } else { bytes2_xor_value(__v_396, __v_400, record) };
+    let __v_402: G = G::from_u64(0);
+    let __v_403: G = if unconstrained { Bytes2::xor(&__v_397, &__v_402) } else { bytes2_xor_value(__v_397, __v_402, record) };
+    let __v_404: G = G::from_u64(256);
+    let __v_405: G = (__v_404 * __v_403);
+    let __v_406: G = (__v_401 + __v_405);
+    let __v_407: G = G::from_u64(256);
+    let __v_408: G = (__v_407 * __v_401);
+    let __v_409: G = G::from_u64(65536);
+    let __v_410: G = (__v_409 * __v_403);
+    let __v_411: G = (__v_408 + __v_410);
+    let __v_412: G = (__v_399 + __v_411);
+    if (__v_388 != __v_412) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_388.as_canonical_u64(), rhs: __v_412.as_canonical_u64(), msg: Some("u64_mul column 14: split_carry hint does not recompose to the column sum".to_string()) });
     }
+    let __ret: [G; OUT_119] = [__v_133, __v_152, __v_171, __v_190, __v_209, __v_228, __v_247, __v_266, __v_285, __v_304, __v_323, __v_342, __v_361, __v_380, __v_399, __v_406];
+    record.function_queries[119].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_222: usize = 1;
-const IN_222: usize = 1;
-const OUT_222: usize = 2;
-fn aiur_fn_222(
-  inp: [G; IN_222],
+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_222], ExecError> {
+) -> Result<[G; OUT_120], 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 __v_4: G = G::from_u64(1);
-        let __v_5: G = G::from_u64(0);
-        let __ret: [G; OUT_222] = [__v_4, __v_5];
-        record.function_queries[222].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      1u64 => {
-        let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[222].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_222] = unsafe { *(result.output.as_ptr() as *const [G; OUT_222]) }; __ret } else { aiur_fn_222(__args, record, io_buffer, __cu)? } };
-        let __v_4: G = __r_arr[0];
-        let __v_5: G = __r_arr[1];
-        match __v_4.as_canonical_u64() {
-          1u64 => {
-            let __v_6: G = G::from_u64(1);
-            let __v_7: G = G::from_u64(1);
-            let __v_8: G = (__v_5 + __v_7);
-            let __ret: [G; OUT_222] = [__v_6, __v_8];
-            record.function_queries[222].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(0);
-            let __ret: [G; OUT_222] = [__v_6, __v_7];
-            record.function_queries[222].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-        }
-      },
-      _ => {
-        let __v_4: G = G::from_u64(0);
-        let __v_5: G = G::from_u64(0);
-        let __ret: [G; OUT_222] = [__v_4, __v_5];
-        record.function_queries[222].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; 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 __v_5: G = G::from_u64(0);
+    let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_0, __v_1, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { 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_6: G = __r_arr[0];
+    let __ret: [G; OUT_120] = [__v_6];
+    record.function_queries[120].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_223: usize = 2;
-const IN_223: usize = 2;
-const OUT_223: usize = 2;
-fn aiur_fn_223(
-  inp: [G; IN_223],
+const INPUT_SIZE_121: usize = 4;
+const IN_121: usize = 4;
+const OUT_121: usize = 1;
+fn aiur_fn_121(
+  inp: [G; IN_121],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_223], ExecError> {
+) -> 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 __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() {
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    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_4: G = __loaded[0];
+    let __v_5: G = __loaded[1];
+    let __v_6: G = __loaded[2];
+    let __v_7: G = __loaded[3];
+    let __v_8: G = __loaded[4];
+    let __v_9: G = __loaded[5];
+    let __v_10: G = __loaded[6];
+    let __v_11: G = __loaded[7];
+    let __v_12: G = __loaded[8];
+    let __v_13: G = __loaded[9];
+    match __v_4.as_canonical_u64() {
       1u64 => {
-        let __v_5: G = G::from_u64(1);
-        let __v_6: G = (__v_1 + __v_5);
-        let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[223].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_223] = unsafe { *(result.output.as_ptr() as *const [G; OUT_223]) }; __ret } else { aiur_fn_223(__args, record, io_buffer, __cu)? } };
-        let __v_7: G = __r_arr[0];
-        let __v_8: G = __r_arr[1];
-        let __ret: [G; OUT_223] = [__v_7, __v_8];
-        record.function_queries[223].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_121] = [__v_2];
+        record.function_queries[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      _ => {
-        let __ret: [G; OUT_223] = [__v_0, __v_1];
-        record.function_queries[223].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+      0u64 => {
+        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 = 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(1);
+        let __v_23: G = G::from_u64(1);
+        let __v_24: G = { let __values: [G; 10] = [__v_22, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; 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_122] = { let __args: [G; IN_122] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_1, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_25: G = __r_arr[0];
+        let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_25, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { 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_26: G = __r_arr[0];
+        let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_2, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[109].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_109] = unsafe { *(result.output.as_ptr() as *const [G; OUT_109]) }; __ret } else { aiur_fn_109(__args, record, io_buffer, __cu)? } };
+        let __v_27: G = __r_arr[0];
+        let __v_28: G = G::from_u64(1);
+        let __v_29: G = (__v_3 + __v_28);
+        let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_13, __v_1, __v_27, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { 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_30: G = __r_arr[0];
+        let __ret: [G; OUT_121] = [__v_30];
+        record.function_queries[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
+      },
     }
   })
 }
 
-const INPUT_SIZE_224: usize = 2;
-const IN_224: usize = 2;
-const OUT_224: usize = 1;
-fn aiur_fn_224(
-  inp: [G; IN_224],
+const INPUT_SIZE_122: usize = 18;
+const IN_122: usize = 18;
+const OUT_122: usize = 1;
+fn aiur_fn_122(
+  inp: [G; IN_122],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_224], ExecError> {
+) -> 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 __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() {
-      0u64 => {
-        let __v_5: G = G::from_u64(0);
-        let __v_6: G = G::from_u64(0);
-        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_224] = [__v_7];
-        record.function_queries[224].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
+    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 __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).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_18: G = __loaded[0];
+    let __v_19: G = __loaded[1];
+    let __v_20: G = __loaded[2];
+    let __v_21: G = __loaded[3];
+    let __v_22: G = __loaded[4];
+    let __v_23: G = __loaded[5];
+    let __v_24: G = __loaded[6];
+    let __v_25: G = __loaded[7];
+    let __v_26: G = __loaded[8];
+    let __v_27: G = __loaded[9];
+    match __v_18.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { 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_5: G = __r_arr[0];
-        let __ret: [G; OUT_224] = [__v_5];
-        record.function_queries[224].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[190].get_mut(&__args[..]) { 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_5: G = __r_arr[0];
-        match __v_5.as_canonical_u64() {
+        let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__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[4].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } else { aiur_fn_4(__args, record, io_buffer, __cu)? } };
+        let __v_28: G = __r_arr[0];
+        match __v_28.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { 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_6: G = __r_arr[0];
-            let __ret: [G; OUT_224] = [__v_6];
-            record.function_queries[224].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_122] = [__v_17];
+            record.function_queries[122].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_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_6: G = __loaded[0];
-            let __v_7: G = __loaded[1];
-            let __v_8: G = __loaded[2];
-            match __v_6.as_canonical_u64() {
-              0u64 => {
-                let __ret: [G; OUT_224] = [__v_1];
-                record.function_queries[224].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              _ => {
-                let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[191].get_mut(&__args[..]) { 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_9: G = __r_arr[0];
-                match __v_9.as_canonical_u64() {
-                  1u64 => {
-                    let __ret: [G; OUT_224] = [__v_0];
-                    record.function_queries[224].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
-                  0u64 => {
-                    let __v_10: G = G::from_u64(3);
-                    let __v_11: G = { let __values: [G; 3] = [__v_10, __v_0, __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_224] = [__v_11];
-                    record.function_queries[224].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
-                  _ => {
-                    return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64()));
-                  },
-                }
-              },
-            }
+            let __r_arr: [G; OUT_725] = { let __args: [G; IN_725] = [__v_17, __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[725].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_725] = unsafe { *(result.output.as_ptr() as *const [G; OUT_725]) }; __ret } else { aiur_fn_725(__args, record, io_buffer, __cu)? } };
+            let __v_29: G = __r_arr[0];
+            let __ret: [G; OUT_122] = [__v_29];
+            record.function_queries[122].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
           },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
+            return Err(ExecError::MatchNoCase(__v_28.as_canonical_u64()));
           },
         }
       },
-    }
-  })
-}
-
-const INPUT_SIZE_225: usize = 1;
-const IN_225: usize = 1;
-const OUT_225: usize = 1;
-fn aiur_fn_225(
-  inp: [G; IN_225],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_225], 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 __v_4: G = G::from_u64(0);
-        let __v_5: G = G::from_u64(0);
-        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_225] = [__v_6];
-        record.function_queries[225].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      4u64 => {
-        let __v_4: G = G::from_u64(4);
-        let __v_5: G = G::from_u64(0);
-        let __v_6: G = { let __values: [G; 3] = [__v_4, __v_2, __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_225] = [__v_6];
-        record.function_queries[225].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      1u64 => {
-        let __v_4: G = G::from_u64(1);
-        let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[225].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_225] = unsafe { *(result.output.as_ptr() as *const [G; OUT_225]) }; __ret } else { aiur_fn_225(__args, record, io_buffer, __cu)? } };
-        let __v_5: G = __r_arr[0];
-        let __v_6: G = G::from_u64(0);
-        let __v_7: G = { let __values: [G; 3] = [__v_4, __v_5, __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_225] = [__v_7];
-        record.function_queries[225].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      2u64 => {
-        let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[225].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_225] = unsafe { *(result.output.as_ptr() as *const [G; OUT_225]) }; __ret } else { aiur_fn_225(__args, record, io_buffer, __cu)? } };
-        let __v_4: G = __r_arr[0];
-        let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[225].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_225] = unsafe { *(result.output.as_ptr() as *const [G; OUT_225]) }; __ret } else { aiur_fn_225(__args, record, io_buffer, __cu)? } };
-        let __v_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { 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_6: G = __r_arr[0];
-        let __ret: [G; OUT_225] = [__v_6];
-        record.function_queries[225].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      3u64 => {
-        let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[225].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_225] = unsafe { *(result.output.as_ptr() as *const [G; OUT_225]) }; __ret } else { aiur_fn_225(__args, record, io_buffer, __cu)? } };
-        let __v_4: G = __r_arr[0];
-        let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[225].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_225] = unsafe { *(result.output.as_ptr() as *const [G; OUT_225]) }; __ret } else { aiur_fn_225(__args, record, io_buffer, __cu)? } };
-        let __v_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[224].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_224] = unsafe { *(result.output.as_ptr() as *const [G; OUT_224]) }; __ret } else { aiur_fn_224(__args, record, io_buffer, __cu)? } };
-        let __v_6: G = __r_arr[0];
-        let __ret: [G; OUT_225] = [__v_6];
-        record.function_queries[225].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_226: usize = 2;
-const IN_226: usize = 2;
-const OUT_226: usize = 1;
-fn aiur_fn_226(
-  inp: [G; IN_226],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_226], 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() {
-      0u64 => {
-        let __v_5: G = G::from_u64(0);
-        let __v_6: G = G::from_u64(0);
-        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_226] = [__v_7];
-        record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      1u64 => {
-        let __v_5: G = G::from_u64(1);
-        let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } else { aiur_fn_226(__args, record, io_buffer, __cu)? } };
-        let __v_6: G = __r_arr[0];
-        let __v_7: G = G::from_u64(0);
-        let __v_8: G = { let __values: [G; 3] = [__v_5, __v_6, __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_226] = [__v_8];
-        record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      2u64 => {
-        let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } else { aiur_fn_226(__args, record, io_buffer, __cu)? } };
-        let __v_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } else { aiur_fn_226(__args, record, io_buffer, __cu)? } };
-        let __v_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { 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_7: G = __r_arr[0];
-        let __ret: [G; OUT_226] = [__v_7];
-        record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      3u64 => {
-        let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } else { aiur_fn_226(__args, record, io_buffer, __cu)? } };
-        let __v_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } else { aiur_fn_226(__args, record, io_buffer, __cu)? } };
-        let __v_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[224].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_224] = unsafe { *(result.output.as_ptr() as *const [G; OUT_224]) }; __ret } else { aiur_fn_224(__args, record, io_buffer, __cu)? } };
-        let __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_226] = [__v_7];
-        record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      4u64 => {
-        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-        let __v_5: G = __r_arr[0];
-        let __ret: [G; OUT_226] = [__v_5];
-        record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_227: usize = 2;
-const IN_227: usize = 2;
-const OUT_227: usize = 1;
-fn aiur_fn_227(
-  inp: [G; IN_227],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_227], 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(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_227] = [__v_7];
-        record.function_queries[227].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __v_5: G = G::from_u64(0);
-        let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } else { aiur_fn_226(__args, record, io_buffer, __cu)? } };
-        let __v_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } else { aiur_fn_227(__args, record, io_buffer, __cu)? } };
-        let __v_7: G = __r_arr[0];
-        let __v_8: G = { let __values: [G; 3] = [__v_5, __v_6, __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_227] = [__v_8];
-        record.function_queries[227].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_228: usize = 2;
-const IN_228: usize = 2;
-const OUT_228: usize = 1;
-fn aiur_fn_228(
-  inp: [G; IN_228],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_228], 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_228] = [__v_0];
-        record.function_queries[228].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } };
-        let __v_5: G = __r_arr[0];
-        let __ret: [G; OUT_228] = [__v_5];
-        record.function_queries[228].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_229: usize = 2;
-const IN_229: usize = 2;
-const OUT_229: usize = 1;
-fn aiur_fn_229(
-  inp: [G; IN_229],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_229], 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() {
       0u64 => {
-        let __v_6: G = G::from_u64(0);
-        let __v_7: G = G::from_u64(0);
-        let __v_8: G = { let __values: [G; 4] = [__v_6, __v_3, __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_229] = [__v_8];
-        record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      1u64 => {
-        let __v_6: G = G::from_u64(1);
-        let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } else { aiur_fn_226(__args, record, io_buffer, __cu)? } };
-        let __v_7: G = __r_arr[0];
-        let __v_8: G = G::from_u64(0);
-        let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __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_229] = [__v_9];
-        record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      2u64 => {
-        let __v_6: G = G::from_u64(2);
-        let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } else { aiur_fn_227(__args, record, io_buffer, __cu)? } };
-        let __v_7: G = __r_arr[0];
-        let __v_8: G = G::from_u64(0);
-        let __v_9: G = { let __values: [G; 4] = [__v_6, __v_3, __v_7, __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_229] = [__v_9];
-        record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      3u64 => {
-        let __v_6: G = G::from_u64(3);
-        let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } };
-        let __v_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } };
-        let __v_8: G = __r_arr[0];
-        let __v_9: G = G::from_u64(0);
-        let __v_10: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_9]; 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_229] = [__v_10];
-        record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      4u64 => {
-        let __v_6: G = G::from_u64(4);
-        let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } };
-        let __v_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } };
-        let __v_8: G = __r_arr[0];
-        let __v_9: G = G::from_u64(0);
-        let __v_10: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_9]; 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_229] = [__v_10];
-        record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      5u64 => {
-        let __v_6: G = G::from_u64(5);
-        let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } };
-        let __v_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } };
-        let __v_8: G = __r_arr[0];
-        let __v_9: G = G::from_u64(0);
-        let __v_10: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_9]; 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_229] = [__v_10];
-        record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      6u64 => {
-        let __v_6: G = G::from_u64(6);
-        let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } };
-        let __v_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } };
-        let __v_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } };
-        let __v_9: G = __r_arr[0];
-        let __v_10: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_9]; 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_229] = [__v_10];
-        record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      7u64 => {
-        let __v_6: G = G::from_u64(7);
-        let __v_7: G = G::from_u64(0);
-        let __v_8: G = { let __values: [G; 4] = [__v_6, __v_3, __v_4, __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_229] = [__v_8];
-        record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      8u64 => {
-        let __v_6: G = G::from_u64(8);
-        let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } };
-        let __v_7: G = __r_arr[0];
-        let __v_8: G = { let __values: [G; 4] = [__v_6, __v_3, __v_4, __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_229] = [__v_8];
-        record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { 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_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 __v_39: G = __r_arr[11];
+        let __v_40: G = __r_arr[12];
+        let __v_41: G = __r_arr[13];
+        let __v_42: G = __r_arr[14];
+        let __v_43: G = __r_arr[15];
+        let __r_arr: [G; OUT_12] = { let __args: [G; IN_12] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __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[12].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_12] = unsafe { *(result.output.as_ptr() as *const [G; OUT_12]) }; __ret } else { aiur_fn_12(__args, record, io_buffer, __cu)? } };
+        let __v_44: G = __r_arr[0];
+        let __v_45: G = __r_arr[1];
+        let __v_46: G = __r_arr[2];
+        let __v_47: G = __r_arr[3];
+        let __v_48: G = __r_arr[4];
+        let __v_49: G = __r_arr[5];
+        let __v_50: G = __r_arr[6];
+        let __v_51: G = __r_arr[7];
+        let __v_52: G = __r_arr[8];
+        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 __r_arr: [G; OUT_12] = { let __args: [G; IN_12] = [__v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59]; let __cu = unconstrained; if let Some(result) = record.function_queries[12].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_12] = unsafe { *(result.output.as_ptr() as *const [G; OUT_12]) }; __ret } else { aiur_fn_12(__args, record, io_buffer, __cu)? } };
+        let __v_60: G = __r_arr[0];
+        let __v_61: G = __r_arr[1];
+        let __v_62: G = __r_arr[2];
+        let __v_63: G = __r_arr[3];
+        let __v_64: G = __r_arr[4];
+        let __v_65: G = __r_arr[5];
+        let __v_66: G = __r_arr[6];
+        let __v_67: G = __r_arr[7];
+        let __v_68: G = __r_arr[8];
+        let __r_arr: [G; OUT_725] = { let __args: [G; IN_725] = [__v_17, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[725].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_725] = unsafe { *(result.output.as_ptr() as *const [G; OUT_725]) }; __ret } else { aiur_fn_725(__args, record, io_buffer, __cu)? } };
+        let __v_69: G = __r_arr[0];
+        let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_27, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_69]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_70: G = __r_arr[0];
+        let __ret: [G; OUT_122] = [__v_70];
+        record.function_queries[122].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+        return Err(ExecError::MatchNoCase(__v_18.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_230: usize = 2;
-const IN_230: usize = 2;
-const OUT_230: usize = 1;
-fn aiur_fn_230(
-  inp: [G; IN_230],
+const INPUT_SIZE_123: usize = 2;
+const IN_123: usize = 2;
+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_230], ExecError> {
+) -> 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 __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 __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; 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: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
-        let __v_12: G = __loaded[0];
-        let __v_13: G = __loaded[1];
-        let __v_14: G = __loaded[2];
-        let __v_15: G = __loaded[3];
-        let __v_16: G = __loaded[4];
-        let __v_17: G = __loaded[5];
-        let __v_18: G = __loaded[6];
-        let __v_19: G = __loaded[7];
-        let __v_20: G = __loaded[8];
-        let __v_21: G = __loaded[9];
-        match __v_12.as_canonical_u64() {
-          1u64 => {
-            let __v_22: G = G::from_u64(1);
-            let __ret: [G; OUT_230] = [__v_22];
-            record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            let __v_22: G = G::from_u64(0);
-            let __ret: [G; OUT_230] = [__v_22];
-            record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-        }
-      },
+    match __v_1.as_canonical_u64() {
       0u64 => {
-        let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; 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: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
-        let __v_12: G = __loaded[0];
-        let __v_13: G = __loaded[1];
-        let __v_14: G = __loaded[2];
-        let __v_15: G = __loaded[3];
-        let __v_16: G = __loaded[4];
-        let __v_17: G = __loaded[5];
-        let __v_18: G = __loaded[6];
-        let __v_19: G = __loaded[7];
-        let __v_20: G = __loaded[8];
-        let __v_21: G = __loaded[9];
-        match __v_12.as_canonical_u64() {
-          1u64 => {
-            let __v_22: G = G::from_u64(0);
-            let __ret: [G; OUT_230] = [__v_22];
-            record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          0u64 => {
-            let __r_arr: [G; OUT_9] = { let __args: [G; IN_9] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[9].get_mut(&__args[..]) { 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_22: G = __r_arr[0];
-            match __v_22.as_canonical_u64() {
-              1u64 => {
-                let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_230] = unsafe { *(result.output.as_ptr() as *const [G; OUT_230]) }; __ret } else { aiur_fn_230(__args, record, io_buffer, __cu)? } };
-                let __v_23: G = __r_arr[0];
-                let __ret: [G; OUT_230] = [__v_23];
-                record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              0u64 => {
-                let __v_23: G = G::from_u64(0);
-                let __ret: [G; OUT_230] = [__v_23];
-                record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              _ => {
-                return Err(ExecError::MatchNoCase(__v_22.as_canonical_u64()));
-              },
-            }
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64()));
-          },
-        }
+        let __ret: [G; OUT_123] = [__v_0];
+        record.function_queries[123].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+        let __v_2: G = G::from_u64(0);
+        let __v_3: G = G::from_u64(0);
+        let __v_4: G = G::from_u64(0);
+        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 = { let __values: [G; 10] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_0]; 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_12: G = G::from_u64(1);
+        let __v_13: G = (__v_1 - __v_12);
+        let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_11, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { 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_14: G = __r_arr[0];
+        let __ret: [G; OUT_123] = [__v_14];
+        record.function_queries[123].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_231: usize = 2;
-const IN_231: usize = 2;
-const OUT_231: usize = 1;
-fn aiur_fn_231(
-  inp: [G; IN_231],
+const INPUT_SIZE_124: usize = 1;
+const IN_124: usize = 1;
+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_231], ExecError> {
+) -> 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 __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 __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { 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_1: G = __r_arr[0];
+    let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; 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: 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 __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_5: G = __loaded[0];
-        let __v_6: G = __loaded[1];
-        let __v_7: G = __loaded[2];
-        match __v_5.as_canonical_u64() {
-          1u64 => {
-            let __v_8: G = G::from_u64(1);
-            let __ret: [G; OUT_231] = [__v_8];
-            record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_231] = [__v_8];
-            record.function_queries[231].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_5: G = __loaded[0];
-        let __v_6: G = __loaded[1];
-        let __v_7: G = __loaded[2];
-        match __v_5.as_canonical_u64() {
-          1u64 => {
-            let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_231] = [__v_8];
-            record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          0u64 => {
-            let __v_8: G = (__v_3 - __v_6);
-            match __v_8.as_canonical_u64() {
-              0u64 => {
-                let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[231].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_231] = unsafe { *(result.output.as_ptr() as *const [G; OUT_231]) }; __ret } else { aiur_fn_231(__args, record, io_buffer, __cu)? } };
-                let __v_9: G = __r_arr[0];
-                let __ret: [G; OUT_231] = [__v_9];
-                record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              _ => {
-                let __v_9: G = G::from_u64(0);
-                let __ret: [G; OUT_231] = [__v_9];
-                record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-            }
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
-          },
-        }
+        let __v_12: G = G::from_u64(1);
+        let __ret: [G; OUT_124] = [__v_12];
+        record.function_queries[124].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+        let __v_12: G = G::from_u64(0);
+        let __ret: [G; OUT_124] = [__v_12];
+        record.function_queries[124].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_232: usize = 4;
-const IN_232: usize = 4;
-const OUT_232: usize = 1;
-fn aiur_fn_232(
-  inp: [G; IN_232],
+const INPUT_SIZE_125: usize = 2;
+const IN_125: usize = 2;
+const OUT_125: usize = 2;
+fn aiur_fn_125(
+  inp: [G; IN_125],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_232], ExecError> {
+) -> 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];
-    match __v_0.as_canonical_u64() {
-      0u64 => {
-        match __v_2.as_canonical_u64() {
-          0u64 => {
-            let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_230] = unsafe { *(result.output.as_ptr() as *const [G; OUT_230]) }; __ret } else { aiur_fn_230(__args, record, io_buffer, __cu)? } };
-            let __v_4: G = __r_arr[0];
-            let __ret: [G; OUT_232] = [__v_4];
-            record.function_queries[232].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            let __v_4: G = G::from_u64(0);
-            let __ret: [G; OUT_232] = [__v_4];
-            record.function_queries[232].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
+    let __bu_qr: (G, G) = unconstrained_big_uint_div_mod_helper(__v_0, __v_1, record)?;
+    let __v_2: G = __bu_qr.0;
+    let __v_3: G = __bu_qr.1;
+    let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { 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_5: G = __r_arr[0];
+    let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { 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_6: G = __r_arr[0];
+    let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_6, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[109].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_109] = unsafe { *(result.output.as_ptr() as *const [G; OUT_109]) }; __ret } else { aiur_fn_109(__args, record, io_buffer, __cu)? } };
+    let __v_7: G = __r_arr[0];
+    let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { 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_8: G = __r_arr[0];
+    let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { 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_9: G = __r_arr[0];
+    if (__v_8 != __v_9) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_8.as_canonical_u64(), rhs: __v_9.as_canonical_u64(), msg: Some("div/mod hint: q*b + r != a".to_string()) });
+    }
+    let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { 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_10: G = __r_arr[0];
+    match __v_10.as_canonical_u64() {
+      1u64 => {
+        let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { 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_11: G = __r_arr[0];
+        let __v_12: G = G::from_u64(1);
+        if (__v_11 != __v_12) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: Some("div/mod hint: division by zero must yield a zero quotient".to_string()) });
         }
+        let __ret: [G; OUT_125] = [__v_4, __v_5];
+        record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
-      1u64 => {
-        match __v_2.as_canonical_u64() {
-          1u64 => {
-            let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[231].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_231] = unsafe { *(result.output.as_ptr() as *const [G; OUT_231]) }; __ret } else { aiur_fn_231(__args, record, io_buffer, __cu)? } };
-            let __v_4: G = __r_arr[0];
-            let __ret: [G; OUT_232] = [__v_4];
-            record.function_queries[232].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            let __v_4: G = G::from_u64(0);
-            let __ret: [G; OUT_232] = [__v_4];
-            record.function_queries[232].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
+      0u64 => {
+        let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { 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_11: G = __r_arr[0];
+        let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { 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_12: G = __r_arr[0];
+        let __v_13: G = G::from_u64(1);
+        if (__v_12 != __v_13) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_12.as_canonical_u64(), rhs: __v_13.as_canonical_u64(), msg: Some("div/mod hint: remainder is not less than the divisor".to_string()) });
         }
+        let __ret: [G; OUT_125] = [__v_4, __v_5];
+        record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64()));
+        return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_233: usize = 0;
-const IN_233: usize = 0;
-const OUT_233: usize = 1;
-fn aiur_fn_233(
-  inp: [G; IN_233],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_233], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(171);
-    let __v_1: G = G::from_u64(104);
-    let __v_2: G = G::from_u64(44);
-    let __v_3: G = G::from_u64(23);
-    let __v_4: G = G::from_u64(120);
-    let __v_5: G = G::from_u64(161);
-    let __v_6: G = G::from_u64(123);
-    let __v_7: G = G::from_u64(190);
-    let __v_8: G = G::from_u64(174);
-    let __v_9: G = G::from_u64(64);
-    let __v_10: G = G::from_u64(50);
-    let __v_11: G = G::from_u64(151);
-    let __v_12: G = G::from_u64(77);
-    let __v_13: G = G::from_u64(243);
-    let __v_14: G = G::from_u64(100);
-    let __v_15: G = G::from_u64(71);
-    let __v_16: G = G::from_u64(206);
-    let __v_17: G = G::from_u64(139);
-    let __v_18: G = G::from_u64(252);
-    let __v_19: G = G::from_u64(171);
-    let __v_20: G = G::from_u64(103);
-    let __v_21: G = G::from_u64(100);
-    let __v_22: G = G::from_u64(163);
-    let __v_23: G = G::from_u64(109);
-    let __v_24: G = G::from_u64(55);
-    let __v_25: G = G::from_u64(133);
-    let __v_26: G = G::from_u64(102);
-    let __v_27: G = G::from_u64(227);
-    let __v_28: G = G::from_u64(173);
-    let __v_29: G = G::from_u64(99);
-    let __v_30: G = G::from_u64(202);
-    let __v_31: G = G::from_u64(184);
-    let __v_32: G = { let __values: [G; 32] = [__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]; 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_233] = [__v_32];
-    record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_234: usize = 0;
-const IN_234: usize = 0;
-const OUT_234: usize = 1;
-fn aiur_fn_234(
-  inp: [G; IN_234],
+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_234], ExecError> {
+) -> Result<[G; OUT_126], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(136);
-    let __v_1: G = G::from_u64(38);
-    let __v_2: G = G::from_u64(102);
-    let __v_3: G = G::from_u64(119);
-    let __v_4: G = G::from_u64(254);
-    let __v_5: G = G::from_u64(231);
-    let __v_6: G = G::from_u64(116);
-    let __v_7: G = G::from_u64(209);
-    let __v_8: G = G::from_u64(9);
-    let __v_9: G = G::from_u64(134);
-    let __v_10: G = G::from_u64(126);
-    let __v_11: G = G::from_u64(75);
-    let __v_12: G = G::from_u64(34);
-    let __v_13: G = G::from_u64(64);
-    let __v_14: G = G::from_u64(40);
-    let __v_15: G = G::from_u64(26);
-    let __v_16: G = G::from_u64(162);
-    let __v_17: G = G::from_u64(238);
-    let __v_18: G = G::from_u64(18);
-    let __v_19: G = G::from_u64(217);
-    let __v_20: G = G::from_u64(121);
-    let __v_21: G = G::from_u64(32);
-    let __v_22: G = G::from_u64(193);
-    let __v_23: G = G::from_u64(23);
-    let __v_24: G = G::from_u64(28);
-    let __v_25: G = G::from_u64(245);
-    let __v_26: G = G::from_u64(193);
-    let __v_27: G = G::from_u64(246);
-    let __v_28: G = G::from_u64(200);
-    let __v_29: G = G::from_u64(125);
-    let __v_30: G = G::from_u64(236);
-    let __v_31: G = G::from_u64(246);
-    let __v_32: G = { let __values: [G; 32] = [__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]; 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_234] = [__v_32];
-    record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { 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_2: G = __r_arr[0];
+    let __v_3: G = __r_arr[1];
+    let __ret: [G; OUT_126] = [__v_2];
+    record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_235: usize = 0;
-const IN_235: usize = 0;
-const OUT_235: usize = 1;
-fn aiur_fn_235(
-  inp: [G; IN_235],
+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_235], ExecError> {
+) -> Result<[G; OUT_127], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(141);
-    let __v_1: G = G::from_u64(196);
-    let __v_2: G = G::from_u64(169);
-    let __v_3: G = G::from_u64(117);
-    let __v_4: G = G::from_u64(39);
-    let __v_5: G = G::from_u64(129);
-    let __v_6: G = G::from_u64(47);
-    let __v_7: G = G::from_u64(139);
-    let __v_8: G = G::from_u64(120);
-    let __v_9: G = G::from_u64(23);
-    let __v_10: G = G::from_u64(183);
-    let __v_11: G = G::from_u64(124);
-    let __v_12: G = G::from_u64(208);
-    let __v_13: G = G::from_u64(121);
-    let __v_14: G = G::from_u64(172);
-    let __v_15: G = G::from_u64(230);
-    let __v_16: G = G::from_u64(20);
-    let __v_17: G = G::from_u64(80);
-    let __v_18: G = G::from_u64(170);
-    let __v_19: G = G::from_u64(1);
-    let __v_20: G = G::from_u64(133);
-    let __v_21: G = G::from_u64(172);
-    let __v_22: G = G::from_u64(88);
-    let __v_23: G = G::from_u64(133);
-    let __v_24: G = G::from_u64(102);
-    let __v_25: G = G::from_u64(30);
-    let __v_26: G = G::from_u64(194);
-    let __v_27: G = G::from_u64(172);
-    let __v_28: G = G::from_u64(186);
-    let __v_29: G = G::from_u64(139);
-    let __v_30: G = G::from_u64(123);
-    let __v_31: G = G::from_u64(208);
-    let __v_32: G = { let __values: [G; 32] = [__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]; 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_235] = [__v_32];
-    record.function_queries[235].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { 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_2: G = __r_arr[0];
+    let __v_3: G = __r_arr[1];
+    let __ret: [G; OUT_127] = [__v_3];
+    record.function_queries[127].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_236: usize = 0;
-const IN_236: usize = 0;
-const OUT_236: usize = 1;
-fn aiur_fn_236(
-  inp: [G; IN_236],
+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_236], ExecError> {
+) -> Result<[G; OUT_128], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(18);
-    let __v_1: G = G::from_u64(73);
-    let __v_2: G = G::from_u64(132);
-    let __v_3: G = G::from_u64(188);
-    let __v_4: G = G::from_u64(185);
-    let __v_5: G = G::from_u64(82);
-    let __v_6: G = G::from_u64(8);
-    let __v_7: G = G::from_u64(160);
-    let __v_8: G = G::from_u64(243);
-    let __v_9: G = G::from_u64(11);
-    let __v_10: G = G::from_u64(182);
-    let __v_11: G = G::from_u64(157);
-    let __v_12: G = G::from_u64(103);
-    let __v_13: G = G::from_u64(54);
-    let __v_14: G = G::from_u64(211);
-    let __v_15: G = G::from_u64(213);
-    let __v_16: G = G::from_u64(148);
-    let __v_17: G = G::from_u64(4);
-    let __v_18: G = G::from_u64(225);
-    let __v_19: G = G::from_u64(21);
-    let __v_20: G = G::from_u64(226);
-    let __v_21: G = G::from_u64(32);
-    let __v_22: G = G::from_u64(32);
-    let __v_23: G = G::from_u64(67);
-    let __v_24: G = G::from_u64(253);
-    let __v_25: G = G::from_u64(163);
-    let __v_26: G = G::from_u64(211);
-    let __v_27: G = G::from_u64(78);
-    let __v_28: G = G::from_u64(1);
-    let __v_29: G = G::from_u64(176);
-    let __v_30: G = G::from_u64(173);
-    let __v_31: G = G::from_u64(22);
-    let __v_32: G = { let __values: [G; 32] = [__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]; 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_236] = [__v_32];
-    record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { 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_2: G = __r_arr[0];
+    match __v_2.as_canonical_u64() {
+      1u64 => {
+        let __ret: [G; OUT_128] = [__v_0];
+        record.function_queries[128].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { 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_3: G = __r_arr[0];
+        let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[128].get_mut(&__args[..]) { 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_4: G = __r_arr[0];
+        let __ret: [G; OUT_128] = [__v_4];
+        record.function_queries[128].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
   })
 }
 
-const INPUT_SIZE_237: usize = 0;
-const IN_237: usize = 0;
-const OUT_237: usize = 1;
-fn aiur_fn_237(
-  inp: [G; IN_237],
+const INPUT_SIZE_129: usize = 2;
+const IN_129: usize = 2;
+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_237], ExecError> {
+) -> Result<[G; OUT_129], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(105);
-    let __v_1: G = G::from_u64(141);
-    let __v_2: G = G::from_u64(213);
-    let __v_3: G = G::from_u64(147);
-    let __v_4: G = G::from_u64(171);
-    let __v_5: G = G::from_u64(251);
-    let __v_6: G = G::from_u64(99);
-    let __v_7: G = G::from_u64(219);
-    let __v_8: G = G::from_u64(54);
-    let __v_9: G = G::from_u64(42);
-    let __v_10: G = G::from_u64(174);
-    let __v_11: G = G::from_u64(245);
-    let __v_12: G = G::from_u64(126);
-    let __v_13: G = G::from_u64(112);
-    let __v_14: G = G::from_u64(167);
-    let __v_15: G = G::from_u64(147);
-    let __v_16: G = G::from_u64(4);
-    let __v_17: G = G::from_u64(79);
-    let __v_18: G = G::from_u64(182);
-    let __v_19: G = G::from_u64(87);
-    let __v_20: G = G::from_u64(37);
-    let __v_21: G = G::from_u64(114);
-    let __v_22: G = G::from_u64(145);
-    let __v_23: G = G::from_u64(238);
-    let __v_24: G = G::from_u64(44);
-    let __v_25: G = G::from_u64(62);
-    let __v_26: G = G::from_u64(153);
-    let __v_27: G = G::from_u64(124);
-    let __v_28: G = G::from_u64(170);
-    let __v_29: G = G::from_u64(66);
-    let __v_30: G = G::from_u64(62);
-    let __v_31: G = G::from_u64(174);
-    let __v_32: G = { let __values: [G; 32] = [__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]; 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_237] = [__v_32];
-    record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { 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_2: G = __r_arr[0];
+    match __v_2.as_canonical_u64() {
+      1u64 => {
+        let __v_3: G = G::from_u64(0);
+        let __v_4: G = G::from_u64(1);
+        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 __v_12: G = G::from_u64(1);
+        let __v_13: G = G::from_u64(1);
+        let __v_14: G = { let __values: [G; 10] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __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 __v_15: G = { let __values: [G; 10] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14]; 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_129] = [__v_15];
+        record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __v_3: G = G::from_u64(0);
+        let __v_4: G = G::from_u64(2);
+        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 __v_12: G = G::from_u64(1);
+        let __v_13: G = G::from_u64(1);
+        let __v_14: G = { let __values: [G; 10] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __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 __v_15: G = { let __values: [G; 10] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14]; 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_125] = { let __args: [G; IN_125] = [__v_1, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { 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_16: G = __r_arr[0];
+        let __v_17: G = __r_arr[1];
+        let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_0, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { 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_18: G = __r_arr[0];
+        let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { 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_19: G = __r_arr[0];
+        let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { 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_20: G = __r_arr[0];
+        let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { 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_22: G = __r_arr[0];
+        match __v_22.as_canonical_u64() {
+          1u64 => {
+            let __ret: [G; OUT_129] = [__v_21];
+            record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          0u64 => {
+            let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_0, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { 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_23: G = __r_arr[0];
+            let __ret: [G; OUT_129] = [__v_23];
+            record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_22.as_canonical_u64()));
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
   })
 }
 
-const INPUT_SIZE_238: usize = 0;
-const IN_238: usize = 0;
-const OUT_238: usize = 1;
-fn aiur_fn_238(
-  inp: [G; IN_238],
+const INPUT_SIZE_130: usize = 16;
+const IN_130: usize = 16;
+const OUT_130: usize = 8;
+fn aiur_fn_130(
+  inp: [G; IN_130],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_238], ExecError> {
+) -> Result<[G; OUT_130], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(119);
-    let __v_1: G = G::from_u64(160);
-    let __v_2: G = G::from_u64(37);
-    let __v_3: G = G::from_u64(193);
-    let __v_4: G = G::from_u64(159);
-    let __v_5: G = G::from_u64(139);
-    let __v_6: G = G::from_u64(225);
-    let __v_7: G = G::from_u64(49);
-    let __v_8: G = G::from_u64(251);
-    let __v_9: G = G::from_u64(157);
-    let __v_10: G = G::from_u64(91);
-    let __v_11: G = G::from_u64(11);
-    let __v_12: G = G::from_u64(236);
-    let __v_13: G = G::from_u64(73);
-    let __v_14: G = G::from_u64(72);
-    let __v_15: G = G::from_u64(23);
-    let __v_16: G = G::from_u64(162);
-    let __v_17: G = G::from_u64(101);
-    let __v_18: G = G::from_u64(56);
-    let __v_19: G = G::from_u64(185);
-    let __v_20: G = G::from_u64(165);
-    let __v_21: G = G::from_u64(80);
-    let __v_22: G = G::from_u64(171);
-    let __v_23: G = G::from_u64(187);
-    let __v_24: G = G::from_u64(206);
-    let __v_25: G = G::from_u64(200);
-    let __v_26: G = G::from_u64(9);
-    let __v_27: G = G::from_u64(159);
-    let __v_28: G = G::from_u64(174);
-    let __v_29: G = G::from_u64(157);
-    let __v_30: G = G::from_u64(228);
-    let __v_31: G = G::from_u64(228);
-    let __v_32: G = { let __values: [G; 32] = [__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]; 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_238] = [__v_32];
-    record.function_queries[238].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    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 = if unconstrained { Bytes2::and(&__v_0, &__v_8) } else { bytes2_and_value(__v_0, __v_8, record) };
+    let __v_17: G = if unconstrained { Bytes2::and(&__v_1, &__v_9) } else { bytes2_and_value(__v_1, __v_9, record) };
+    let __v_18: G = if unconstrained { Bytes2::and(&__v_2, &__v_10) } else { bytes2_and_value(__v_2, __v_10, record) };
+    let __v_19: G = if unconstrained { Bytes2::and(&__v_3, &__v_11) } else { bytes2_and_value(__v_3, __v_11, record) };
+    let __v_20: G = if unconstrained { Bytes2::and(&__v_4, &__v_12) } else { bytes2_and_value(__v_4, __v_12, record) };
+    let __v_21: G = if unconstrained { Bytes2::and(&__v_5, &__v_13) } else { bytes2_and_value(__v_5, __v_13, record) };
+    let __v_22: G = if unconstrained { Bytes2::and(&__v_6, &__v_14) } else { bytes2_and_value(__v_6, __v_14, record) };
+    let __v_23: G = if unconstrained { Bytes2::and(&__v_7, &__v_15) } else { bytes2_and_value(__v_7, __v_15, record) };
+    let __ret: [G; OUT_130] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23];
+    record.function_queries[130].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_239: usize = 0;
-const IN_239: usize = 0;
-const OUT_239: usize = 1;
-fn aiur_fn_239(
-  inp: [G; IN_239],
+const INPUT_SIZE_131: usize = 16;
+const IN_131: usize = 16;
+const OUT_131: usize = 8;
+fn aiur_fn_131(
+  inp: [G; IN_131],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_239], ExecError> {
+) -> Result<[G; OUT_131], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(144);
-    let __v_1: G = G::from_u64(202);
-    let __v_2: G = G::from_u64(129);
-    let __v_3: G = G::from_u64(48);
-    let __v_4: G = G::from_u64(115);
-    let __v_5: G = G::from_u64(92);
-    let __v_6: G = G::from_u64(141);
-    let __v_7: G = G::from_u64(154);
-    let __v_8: G = G::from_u64(52);
-    let __v_9: G = G::from_u64(0);
-    let __v_10: G = G::from_u64(90);
-    let __v_11: G = G::from_u64(137);
-    let __v_12: G = G::from_u64(67);
-    let __v_13: G = G::from_u64(181);
-    let __v_14: G = G::from_u64(159);
-    let __v_15: G = G::from_u64(225);
-    let __v_16: G = G::from_u64(223);
-    let __v_17: G = G::from_u64(24);
-    let __v_18: G = G::from_u64(46);
-    let __v_19: G = G::from_u64(8);
-    let __v_20: G = G::from_u64(169);
-    let __v_21: G = G::from_u64(242);
-    let __v_22: G = G::from_u64(191);
-    let __v_23: G = G::from_u64(199);
-    let __v_24: G = G::from_u64(220);
-    let __v_25: G = G::from_u64(131);
-    let __v_26: G = G::from_u64(35);
-    let __v_27: G = G::from_u64(34);
-    let __v_28: G = G::from_u64(150);
-    let __v_29: G = G::from_u64(89);
-    let __v_30: G = G::from_u64(165);
-    let __v_31: G = G::from_u64(116);
-    let __v_32: G = { let __values: [G; 32] = [__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]; 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_239] = [__v_32];
-    record.function_queries[239].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    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 = if unconstrained { Bytes2::or(&__v_0, &__v_8) } else { bytes2_or_value(__v_0, __v_8, record) };
+    let __v_17: G = if unconstrained { Bytes2::or(&__v_1, &__v_9) } else { bytes2_or_value(__v_1, __v_9, record) };
+    let __v_18: G = if unconstrained { Bytes2::or(&__v_2, &__v_10) } else { bytes2_or_value(__v_2, __v_10, record) };
+    let __v_19: G = if unconstrained { Bytes2::or(&__v_3, &__v_11) } else { bytes2_or_value(__v_3, __v_11, record) };
+    let __v_20: G = if unconstrained { Bytes2::or(&__v_4, &__v_12) } else { bytes2_or_value(__v_4, __v_12, record) };
+    let __v_21: G = if unconstrained { Bytes2::or(&__v_5, &__v_13) } else { bytes2_or_value(__v_5, __v_13, record) };
+    let __v_22: G = if unconstrained { Bytes2::or(&__v_6, &__v_14) } else { bytes2_or_value(__v_6, __v_14, record) };
+    let __v_23: G = if unconstrained { Bytes2::or(&__v_7, &__v_15) } else { bytes2_or_value(__v_7, __v_15, record) };
+    let __ret: [G; OUT_131] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23];
+    record.function_queries[131].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_240: usize = 0;
-const IN_240: usize = 0;
-const OUT_240: usize = 1;
-fn aiur_fn_240(
-  inp: [G; IN_240],
+const INPUT_SIZE_132: usize = 16;
+const IN_132: usize = 16;
+const OUT_132: usize = 8;
+fn aiur_fn_132(
+  inp: [G; IN_132],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_240], ExecError> {
+) -> Result<[G; OUT_132], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(159);
-    let __v_1: G = G::from_u64(216);
-    let __v_2: G = G::from_u64(231);
-    let __v_3: G = G::from_u64(69);
-    let __v_4: G = G::from_u64(154);
-    let __v_5: G = G::from_u64(29);
-    let __v_6: G = G::from_u64(45);
-    let __v_7: G = G::from_u64(238);
-    let __v_8: G = G::from_u64(240);
-    let __v_9: G = G::from_u64(10);
-    let __v_10: G = G::from_u64(73);
-    let __v_11: G = G::from_u64(146);
-    let __v_12: G = G::from_u64(165);
-    let __v_13: G = G::from_u64(4);
-    let __v_14: G = G::from_u64(25);
-    let __v_15: G = G::from_u64(186);
-    let __v_16: G = G::from_u64(198);
-    let __v_17: G = G::from_u64(108);
-    let __v_18: G = G::from_u64(3);
-    let __v_19: G = G::from_u64(8);
-    let __v_20: G = G::from_u64(43);
-    let __v_21: G = G::from_u64(88);
-    let __v_22: G = G::from_u64(173);
-    let __v_23: G = G::from_u64(224);
-    let __v_24: G = G::from_u64(116);
-    let __v_25: G = G::from_u64(34);
-    let __v_26: G = G::from_u64(137);
-    let __v_27: G = G::from_u64(111);
-    let __v_28: G = G::from_u64(19);
-    let __v_29: G = G::from_u64(3);
-    let __v_30: G = G::from_u64(61);
-    let __v_31: G = G::from_u64(116);
-    let __v_32: G = { let __values: [G; 32] = [__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]; 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_240] = [__v_32];
-    record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    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 = if unconstrained { Bytes2::xor(&__v_0, &__v_8) } else { bytes2_xor_value(__v_0, __v_8, record) };
+    let __v_17: G = if unconstrained { Bytes2::xor(&__v_1, &__v_9) } else { bytes2_xor_value(__v_1, __v_9, record) };
+    let __v_18: G = if unconstrained { Bytes2::xor(&__v_2, &__v_10) } else { bytes2_xor_value(__v_2, __v_10, record) };
+    let __v_19: G = if unconstrained { Bytes2::xor(&__v_3, &__v_11) } else { bytes2_xor_value(__v_3, __v_11, record) };
+    let __v_20: G = if unconstrained { Bytes2::xor(&__v_4, &__v_12) } else { bytes2_xor_value(__v_4, __v_12, record) };
+    let __v_21: G = if unconstrained { Bytes2::xor(&__v_5, &__v_13) } else { bytes2_xor_value(__v_5, __v_13, record) };
+    let __v_22: G = if unconstrained { Bytes2::xor(&__v_6, &__v_14) } else { bytes2_xor_value(__v_6, __v_14, record) };
+    let __v_23: G = if unconstrained { Bytes2::xor(&__v_7, &__v_15) } else { bytes2_xor_value(__v_7, __v_15, record) };
+    let __ret: [G; OUT_132] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23];
+    record.function_queries[132].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_241: usize = 0;
-const IN_241: usize = 0;
-const OUT_241: usize = 1;
-fn aiur_fn_241(
-  inp: [G; IN_241],
+const INPUT_SIZE_133: usize = 2;
+const IN_133: usize = 2;
+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_241], ExecError> {
+) -> Result<[G; OUT_133], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(197);
-    let __v_1: G = G::from_u64(247);
-    let __v_2: G = G::from_u64(177);
-    let __v_3: G = G::from_u64(150);
-    let __v_4: G = G::from_u64(99);
-    let __v_5: G = G::from_u64(228);
-    let __v_6: G = G::from_u64(73);
-    let __v_7: G = G::from_u64(158);
-    let __v_8: G = G::from_u64(112);
-    let __v_9: G = G::from_u64(225);
-    let __v_10: G = G::from_u64(178);
-    let __v_11: G = G::from_u64(100);
-    let __v_12: G = G::from_u64(81);
-    let __v_13: G = G::from_u64(98);
-    let __v_14: G = G::from_u64(197);
-    let __v_15: G = G::from_u64(190);
-    let __v_16: G = G::from_u64(21);
-    let __v_17: G = G::from_u64(250);
-    let __v_18: G = G::from_u64(134);
-    let __v_19: G = G::from_u64(15);
-    let __v_20: G = G::from_u64(79);
-    let __v_21: G = G::from_u64(129);
-    let __v_22: G = G::from_u64(87);
-    let __v_23: G = G::from_u64(227);
-    let __v_24: G = G::from_u64(49);
-    let __v_25: G = G::from_u64(174);
-    let __v_26: G = G::from_u64(84);
-    let __v_27: G = G::from_u64(108);
-    let __v_28: G = G::from_u64(111);
-    let __v_29: G = G::from_u64(115);
-    let __v_30: G = G::from_u64(55);
-    let __v_31: G = G::from_u64(35);
-    let __v_32: G = { let __values: [G; 32] = [__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]; 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_241] = [__v_32];
-    record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
+    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 __v_12: G = G::from_u64(1);
+        let __v_13: G = G::from_u64(1);
+        let __v_14: G = { let __values: [G; 10] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __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_133] = [__v_14];
+        record.function_queries[133].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_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: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
+        let __v_12: G = __loaded[0];
+        let __v_13: G = __loaded[1];
+        let __v_14: G = __loaded[2];
+        let __v_15: G = __loaded[3];
+        let __v_16: G = __loaded[4];
+        let __v_17: G = __loaded[5];
+        let __v_18: G = __loaded[6];
+        let __v_19: G = __loaded[7];
+        let __v_20: G = __loaded[8];
+        let __v_21: G = __loaded[9];
+        match __v_12.as_canonical_u64() {
+          1u64 => {
+            let __v_22: G = G::from_u64(1);
+            let __v_23: G = G::from_u64(1);
+            let __v_24: G = { let __values: [G; 10] = [__v_22, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; 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_133] = [__v_24];
+            record.function_queries[133].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          0u64 => {
+            let __v_22: G = G::from_u64(0);
+            let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { 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_23: G = __r_arr[0];
+            let __v_24: G = __r_arr[1];
+            let __v_25: G = __r_arr[2];
+            let __v_26: G = __r_arr[3];
+            let __v_27: G = __r_arr[4];
+            let __v_28: G = __r_arr[5];
+            let __v_29: G = __r_arr[6];
+            let __v_30: G = __r_arr[7];
+            let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { 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_31: G = __r_arr[0];
+            let __v_32: G = { let __values: [G; 10] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; 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_133] = [__v_32];
+            record.function_queries[133].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_242: usize = 0;
-const IN_242: usize = 0;
-const OUT_242: usize = 1;
-fn aiur_fn_242(
-  inp: [G; IN_242],
+const INPUT_SIZE_134: usize = 2;
+const IN_134: usize = 2;
+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_242], ExecError> {
+) -> Result<[G; OUT_134], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(202);
-    let __v_1: G = G::from_u64(202);
-    let __v_2: G = G::from_u64(234);
-    let __v_3: G = G::from_u64(151);
-    let __v_4: G = G::from_u64(244);
-    let __v_5: G = G::from_u64(205);
-    let __v_6: G = G::from_u64(186);
-    let __v_7: G = G::from_u64(10);
-    let __v_8: G = G::from_u64(74);
-    let __v_9: G = G::from_u64(10);
-    let __v_10: G = G::from_u64(247);
-    let __v_11: G = G::from_u64(16);
-    let __v_12: G = G::from_u64(5);
-    let __v_13: G = G::from_u64(208);
-    let __v_14: G = G::from_u64(81);
-    let __v_15: G = G::from_u64(125);
-    let __v_16: G = G::from_u64(24);
-    let __v_17: G = G::from_u64(24);
-    let __v_18: G = G::from_u64(171);
-    let __v_19: G = G::from_u64(38);
-    let __v_20: G = G::from_u64(35);
-    let __v_21: G = G::from_u64(189);
-    let __v_22: G = G::from_u64(46);
-    let __v_23: G = G::from_u64(167);
-    let __v_24: G = G::from_u64(250);
-    let __v_25: G = G::from_u64(140);
-    let __v_26: G = G::from_u64(99);
-    let __v_27: G = G::from_u64(122);
-    let __v_28: G = G::from_u64(14);
-    let __v_29: G = G::from_u64(61);
-    let __v_30: G = G::from_u64(51);
-    let __v_31: G = G::from_u64(18);
-    let __v_32: G = { let __values: [G; 32] = [__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]; 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_242] = [__v_32];
-    record.function_queries[242].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
+    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_134] = [__v_1];
+        record.function_queries[134].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_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: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
+        let __v_12: G = __loaded[0];
+        let __v_13: G = __loaded[1];
+        let __v_14: G = __loaded[2];
+        let __v_15: G = __loaded[3];
+        let __v_16: G = __loaded[4];
+        let __v_17: G = __loaded[5];
+        let __v_18: G = __loaded[6];
+        let __v_19: G = __loaded[7];
+        let __v_20: G = __loaded[8];
+        let __v_21: G = __loaded[9];
+        match __v_12.as_canonical_u64() {
+          1u64 => {
+            let __ret: [G; OUT_134] = [__v_0];
+            record.function_queries[134].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          0u64 => {
+            let __v_22: G = G::from_u64(0);
+            let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[131].get_mut(&__args[..]) { 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_23: G = __r_arr[0];
+            let __v_24: G = __r_arr[1];
+            let __v_25: G = __r_arr[2];
+            let __v_26: G = __r_arr[3];
+            let __v_27: G = __r_arr[4];
+            let __v_28: G = __r_arr[5];
+            let __v_29: G = __r_arr[6];
+            let __v_30: G = __r_arr[7];
+            let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[134].get_mut(&__args[..]) { 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_31: G = __r_arr[0];
+            let __v_32: G = { let __values: [G; 10] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; 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_134] = [__v_32];
+            record.function_queries[134].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_243: usize = 0;
-const IN_243: usize = 0;
-const OUT_243: usize = 1;
-fn aiur_fn_243(
-  inp: [G; IN_243],
+const INPUT_SIZE_135: usize = 2;
+const IN_135: usize = 2;
+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_243], ExecError> {
+) -> Result<[G; OUT_135], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(230);
-    let __v_1: G = G::from_u64(235);
-    let __v_2: G = G::from_u64(163);
-    let __v_3: G = G::from_u64(200);
-    let __v_4: G = G::from_u64(180);
-    let __v_5: G = G::from_u64(209);
-    let __v_6: G = G::from_u64(159);
-    let __v_7: G = G::from_u64(106);
-    let __v_8: G = G::from_u64(16);
-    let __v_9: G = G::from_u64(118);
-    let __v_10: G = G::from_u64(179);
-    let __v_11: G = G::from_u64(159);
-    let __v_12: G = G::from_u64(168);
-    let __v_13: G = G::from_u64(154);
-    let __v_14: G = G::from_u64(236);
-    let __v_15: G = G::from_u64(97);
-    let __v_16: G = G::from_u64(220);
-    let __v_17: G = G::from_u64(203);
-    let __v_18: G = G::from_u64(185);
-    let __v_19: G = G::from_u64(96);
-    let __v_20: G = G::from_u64(248);
-    let __v_21: G = G::from_u64(61);
-    let __v_22: G = G::from_u64(154);
-    let __v_23: G = G::from_u64(98);
-    let __v_24: G = G::from_u64(230);
-    let __v_25: G = G::from_u64(172);
-    let __v_26: G = G::from_u64(243);
-    let __v_27: G = G::from_u64(90);
-    let __v_28: G = G::from_u64(105);
-    let __v_29: G = G::from_u64(201);
-    let __v_30: G = G::from_u64(160);
-    let __v_31: G = G::from_u64(164);
-    let __v_32: G = { let __values: [G; 32] = [__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]; 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_243] = [__v_32];
-    record.function_queries[243].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    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_135] = [__v_1];
+        record.function_queries[135].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_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: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
+        let __v_12: G = __loaded[0];
+        let __v_13: G = __loaded[1];
+        let __v_14: G = __loaded[2];
+        let __v_15: G = __loaded[3];
+        let __v_16: G = __loaded[4];
+        let __v_17: G = __loaded[5];
+        let __v_18: G = __loaded[6];
+        let __v_19: G = __loaded[7];
+        let __v_20: G = __loaded[8];
+        let __v_21: G = __loaded[9];
+        match __v_12.as_canonical_u64() {
+          1u64 => {
+            let __ret: [G; OUT_135] = [__v_0];
+            record.function_queries[135].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          0u64 => {
+            let __v_22: G = G::from_u64(0);
+            let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { 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_23: G = __r_arr[0];
+            let __v_24: G = __r_arr[1];
+            let __v_25: G = __r_arr[2];
+            let __v_26: G = __r_arr[3];
+            let __v_27: G = __r_arr[4];
+            let __v_28: G = __r_arr[5];
+            let __v_29: G = __r_arr[6];
+            let __v_30: G = __r_arr[7];
+            let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[135].get_mut(&__args[..]) { 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_31: G = __r_arr[0];
+            let __v_32: G = { let __values: [G; 10] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; 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_135] = [__v_32];
+            record.function_queries[135].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_136: usize = 2;
+const IN_136: usize = 2;
+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 = G::from_u64(0);
+    let __v_3: G = G::from_u64(2);
+    let __v_4: G = G::from_u64(0);
+    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(1);
+    let __v_12: G = G::from_u64(1);
+    let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; 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_14: G = { let __values: [G; 10] = [__v_2, __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 __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { 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_15: G = __r_arr[0];
+    let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_0, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { 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_16: G = __r_arr[0];
+    let __ret: [G; OUT_136] = [__v_16];
+    record.function_queries[136].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_244: usize = 0;
-const IN_244: usize = 0;
-const OUT_244: usize = 1;
-fn aiur_fn_244(
-  inp: [G; IN_244],
+const INPUT_SIZE_137: usize = 2;
+const IN_137: usize = 2;
+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_244], ExecError> {
+) -> Result<[G; OUT_137], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(3);
-    let __v_1: G = G::from_u64(107);
-    let __v_2: G = G::from_u64(99);
-    let __v_3: G = G::from_u64(213);
-    let __v_4: G = G::from_u64(204);
-    let __v_5: G = G::from_u64(9);
-    let __v_6: G = G::from_u64(97);
-    let __v_7: G = G::from_u64(233);
-    let __v_8: G = G::from_u64(32);
-    let __v_9: G = G::from_u64(222);
-    let __v_10: G = G::from_u64(229);
-    let __v_11: G = G::from_u64(14);
-    let __v_12: G = G::from_u64(115);
-    let __v_13: G = G::from_u64(100);
-    let __v_14: G = G::from_u64(236);
-    let __v_15: G = G::from_u64(13);
-    let __v_16: G = G::from_u64(211);
-    let __v_17: G = G::from_u64(249);
-    let __v_18: G = G::from_u64(195);
-    let __v_19: G = G::from_u64(138);
-    let __v_20: G = G::from_u64(156);
-    let __v_21: G = G::from_u64(172);
-    let __v_22: G = G::from_u64(228);
-    let __v_23: G = G::from_u64(14);
-    let __v_24: G = G::from_u64(81);
-    let __v_25: G = G::from_u64(59);
-    let __v_26: G = G::from_u64(56);
-    let __v_27: G = G::from_u64(53);
-    let __v_28: G = G::from_u64(222);
-    let __v_29: G = G::from_u64(200);
-    let __v_30: G = G::from_u64(224);
-    let __v_31: G = G::from_u64(201);
-    let __v_32: G = { let __values: [G; 32] = [__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]; 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_244] = [__v_32];
-    record.function_queries[244].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = G::from_u64(0);
+    let __v_3: G = G::from_u64(2);
+    let __v_4: G = G::from_u64(0);
+    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(1);
+    let __v_12: G = G::from_u64(1);
+    let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; 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_14: G = { let __values: [G; 10] = [__v_2, __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 __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { 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_15: G = __r_arr[0];
+    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { 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_16: G = __r_arr[0];
+    let __ret: [G; OUT_137] = [__v_16];
+    record.function_queries[137].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_245: usize = 0;
-const IN_245: usize = 0;
-const OUT_245: usize = 1;
-fn aiur_fn_245(
-  inp: [G; IN_245],
+const INPUT_SIZE_138: usize = 0;
+const IN_138: usize = 0;
+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_245], ExecError> {
+) -> Result<[G; OUT_138], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(108);
-    let __v_1: G = G::from_u64(155);
-    let __v_2: G = G::from_u64(214);
-    let __v_3: G = G::from_u64(14);
-    let __v_4: G = G::from_u64(30);
-    let __v_5: G = G::from_u64(174);
-    let __v_6: G = G::from_u64(147);
-    let __v_7: G = G::from_u64(142);
-    let __v_8: G = G::from_u64(86);
-    let __v_9: G = G::from_u64(38);
-    let __v_10: G = G::from_u64(202);
-    let __v_11: G = G::from_u64(35);
-    let __v_12: G = G::from_u64(125);
-    let __v_13: G = G::from_u64(188);
-    let __v_14: G = G::from_u64(167);
-    let __v_15: G = G::from_u64(253);
-    let __v_16: G = G::from_u64(149);
-    let __v_17: G = G::from_u64(15);
-    let __v_18: G = G::from_u64(46);
-    let __v_19: G = G::from_u64(153);
-    let __v_20: G = G::from_u64(226);
-    let __v_21: G = G::from_u64(52);
-    let __v_22: G = G::from_u64(169);
-    let __v_23: G = G::from_u64(156);
-    let __v_24: G = G::from_u64(35);
-    let __v_25: G = G::from_u64(207);
-    let __v_26: G = G::from_u64(220);
-    let __v_27: G = G::from_u64(41);
+    let __v_0: G = G::from_u64(211);
+    let __v_1: G = G::from_u64(151);
+    let __v_2: G = G::from_u64(55);
+    let __v_3: G = G::from_u64(1);
+    let __v_4: G = G::from_u64(87);
+    let __v_5: G = G::from_u64(251);
+    let __v_6: G = G::from_u64(154);
+    let __v_7: G = G::from_u64(226);
+    let __v_8: G = G::from_u64(198);
+    let __v_9: G = G::from_u64(225);
+    let __v_10: G = G::from_u64(237);
+    let __v_11: G = G::from_u64(167);
+    let __v_12: G = G::from_u64(159);
+    let __v_13: G = G::from_u64(235);
+    let __v_14: G = G::from_u64(16);
+    let __v_15: G = G::from_u64(191);
+    let __v_16: G = G::from_u64(73);
+    let __v_17: G = G::from_u64(116);
+    let __v_18: G = G::from_u64(1);
+    let __v_19: G = G::from_u64(116);
+    let __v_20: G = G::from_u64(26);
+    let __v_21: G = G::from_u64(186);
+    let __v_22: G = G::from_u64(120);
+    let __v_23: G = G::from_u64(143);
+    let __v_24: G = G::from_u64(171);
+    let __v_25: G = G::from_u64(114);
+    let __v_26: G = G::from_u64(108);
+    let __v_27: G = G::from_u64(250);
     let __v_28: G = G::from_u64(76);
-    let __v_29: G = G::from_u64(167);
-    let __v_30: G = G::from_u64(173);
-    let __v_31: G = G::from_u64(206);
+    let __v_29: G = G::from_u64(70);
+    let __v_30: G = G::from_u64(125);
+    let __v_31: G = G::from_u64(182);
     let __v_32: G = { let __values: [G; 32] = [__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]; 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_245] = [__v_32];
-    record.function_queries[245].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_138] = [__v_32];
+    record.function_queries[138].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_246: usize = 0;
-const IN_246: usize = 0;
-const OUT_246: usize = 1;
-fn aiur_fn_246(
-  inp: [G; IN_246],
+const INPUT_SIZE_139: usize = 0;
+const IN_139: usize = 0;
+const OUT_139: usize = 1;
+fn aiur_fn_139(
+  inp: [G; IN_139],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_246], ExecError> {
+) -> Result<[G; OUT_139], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(236);
-    let __v_1: G = G::from_u64(31);
-    let __v_2: G = G::from_u64(96);
-    let __v_3: G = G::from_u64(193);
-    let __v_4: G = G::from_u64(162);
-    let __v_5: G = G::from_u64(141);
-    let __v_6: G = G::from_u64(72);
-    let __v_7: G = G::from_u64(188);
+    let __v_0: G = G::from_u64(222);
+    let __v_1: G = G::from_u64(245);
+    let __v_2: G = G::from_u64(45);
+    let __v_3: G = G::from_u64(29);
+    let __v_4: G = G::from_u64(173);
+    let __v_5: G = G::from_u64(95);
+    let __v_6: G = G::from_u64(16);
+    let __v_7: G = G::from_u64(207);
     let __v_8: G = G::from_u64(152);
-    let __v_9: G = G::from_u64(254);
-    let __v_10: G = G::from_u64(62);
-    let __v_11: G = G::from_u64(247);
-    let __v_12: G = G::from_u64(45);
-    let __v_13: G = G::from_u64(37);
-    let __v_14: G = G::from_u64(81);
-    let __v_15: G = G::from_u64(50);
-    let __v_16: G = G::from_u64(115);
-    let __v_17: G = G::from_u64(90);
-    let __v_18: G = G::from_u64(80);
-    let __v_19: G = G::from_u64(60);
-    let __v_20: G = G::from_u64(195);
-    let __v_21: G = G::from_u64(110);
-    let __v_22: G = G::from_u64(63);
-    let __v_23: G = G::from_u64(240);
-    let __v_24: G = G::from_u64(242);
-    let __v_25: G = G::from_u64(46);
-    let __v_26: G = G::from_u64(61);
-    let __v_27: G = G::from_u64(72);
-    let __v_28: G = G::from_u64(110);
-    let __v_29: G = G::from_u64(38);
-    let __v_30: G = G::from_u64(110);
-    let __v_31: G = G::from_u64(190);
+    let __v_9: G = G::from_u64(147);
+    let __v_10: G = G::from_u64(201);
+    let __v_11: G = G::from_u64(69);
+    let __v_12: G = G::from_u64(225);
+    let __v_13: G = G::from_u64(105);
+    let __v_14: G = G::from_u64(113);
+    let __v_15: G = G::from_u64(141);
+    let __v_16: G = G::from_u64(98);
+    let __v_17: G = G::from_u64(177);
+    let __v_18: G = G::from_u64(94);
+    let __v_19: G = G::from_u64(45);
+    let __v_20: G = G::from_u64(210);
+    let __v_21: G = G::from_u64(201);
+    let __v_22: G = G::from_u64(6);
+    let __v_23: G = G::from_u64(110);
+    let __v_24: G = G::from_u64(89);
+    let __v_25: G = G::from_u64(123);
+    let __v_26: G = G::from_u64(157);
+    let __v_27: G = G::from_u64(69);
+    let __v_28: G = G::from_u64(112);
+    let __v_29: G = G::from_u64(186);
+    let __v_30: G = G::from_u64(5);
+    let __v_31: G = G::from_u64(110);
     let __v_32: G = { let __values: [G; 32] = [__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]; 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_246] = [__v_32];
-    record.function_queries[246].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_139] = [__v_32];
+    record.function_queries[139].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_247: usize = 0;
-const IN_247: usize = 0;
-const OUT_247: usize = 1;
-fn aiur_fn_247(
-  inp: [G; IN_247],
+const INPUT_SIZE_140: usize = 0;
+const IN_140: usize = 0;
+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_247], ExecError> {
+) -> Result<[G; OUT_140], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(180);
-    let __v_1: G = G::from_u64(178);
-    let __v_2: G = G::from_u64(108);
-    let __v_3: G = G::from_u64(46);
-    let __v_4: G = G::from_u64(41);
-    let __v_5: G = G::from_u64(147);
-    let __v_6: G = G::from_u64(28);
-    let __v_7: G = G::from_u64(6);
-    let __v_8: G = G::from_u64(232);
-    let __v_9: G = G::from_u64(133);
-    let __v_10: G = G::from_u64(145);
-    let __v_11: G = G::from_u64(70);
-    let __v_12: G = G::from_u64(19);
-    let __v_13: G = G::from_u64(250);
-    let __v_14: G = G::from_u64(255);
-    let __v_15: G = G::from_u64(88);
-    let __v_16: G = G::from_u64(86);
-    let __v_17: G = G::from_u64(19);
-    let __v_18: G = G::from_u64(142);
-    let __v_19: G = G::from_u64(92);
-    let __v_20: G = G::from_u64(176);
-    let __v_21: G = G::from_u64(150);
-    let __v_22: G = G::from_u64(32);
-    let __v_23: G = G::from_u64(221);
-    let __v_24: G = G::from_u64(182);
-    let __v_25: G = G::from_u64(146);
-    let __v_26: G = G::from_u64(26);
-    let __v_27: G = G::from_u64(52);
-    let __v_28: G = G::from_u64(45);
-    let __v_29: G = G::from_u64(237);
-    let __v_30: G = G::from_u64(137);
-    let __v_31: G = G::from_u64(87);
+    let __v_0: G = G::from_u64(145);
+    let __v_1: G = G::from_u64(79);
+    let __v_2: G = G::from_u64(156);
+    let __v_3: G = G::from_u64(1);
+    let __v_4: G = G::from_u64(136);
+    let __v_5: G = G::from_u64(72);
+    let __v_6: G = G::from_u64(83);
+    let __v_7: G = G::from_u64(101);
+    let __v_8: G = G::from_u64(46);
+    let __v_9: G = G::from_u64(146);
+    let __v_10: G = G::from_u64(36);
+    let __v_11: G = G::from_u64(220);
+    let __v_12: G = G::from_u64(81);
+    let __v_13: G = G::from_u64(31);
+    let __v_14: G = G::from_u64(134);
+    let __v_15: G = G::from_u64(125);
+    let __v_16: G = G::from_u64(84);
+    let __v_17: G = G::from_u64(8);
+    let __v_18: G = G::from_u64(81);
+    let __v_19: G = G::from_u64(127);
+    let __v_20: G = G::from_u64(59);
+    let __v_21: G = G::from_u64(235);
+    let __v_22: G = G::from_u64(49);
+    let __v_23: G = G::from_u64(146);
+    let __v_24: G = G::from_u64(252);
+    let __v_25: G = G::from_u64(68);
+    let __v_26: G = G::from_u64(119);
+    let __v_27: G = G::from_u64(224);
+    let __v_28: G = G::from_u64(233);
+    let __v_29: G = G::from_u64(89);
+    let __v_30: G = G::from_u64(76);
+    let __v_31: G = G::from_u64(136);
     let __v_32: G = { let __values: [G; 32] = [__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]; 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_247] = [__v_32];
-    record.function_queries[247].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_140] = [__v_32];
+    record.function_queries[140].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_248: usize = 0;
-const IN_248: usize = 0;
-const OUT_248: usize = 1;
-fn aiur_fn_248(
-  inp: [G; IN_248],
+const INPUT_SIZE_141: usize = 0;
+const IN_141: usize = 0;
+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_248], ExecError> {
+) -> Result<[G; OUT_141], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(192);
-    let __v_1: G = G::from_u64(19);
-    let __v_2: G = G::from_u64(193);
-    let __v_3: G = G::from_u64(83);
-    let __v_4: G = G::from_u64(235);
-    let __v_5: G = G::from_u64(240);
-    let __v_6: G = G::from_u64(32);
-    let __v_7: G = G::from_u64(40);
-    let __v_8: G = G::from_u64(174);
-    let __v_9: G = G::from_u64(210);
-    let __v_10: G = G::from_u64(100);
-    let __v_11: G = G::from_u64(51);
-    let __v_12: G = G::from_u64(60);
-    let __v_13: G = G::from_u64(30);
-    let __v_14: G = G::from_u64(76);
-    let __v_15: G = G::from_u64(133);
-    let __v_16: G = G::from_u64(1);
-    let __v_17: G = G::from_u64(125);
-    let __v_18: G = G::from_u64(11);
-    let __v_19: G = G::from_u64(135);
-    let __v_20: G = G::from_u64(2);
-    let __v_21: G = G::from_u64(93);
-    let __v_22: G = G::from_u64(117);
-    let __v_23: G = G::from_u64(150);
-    let __v_24: G = G::from_u64(169);
-    let __v_25: G = G::from_u64(105);
-    let __v_26: G = G::from_u64(113);
-    let __v_27: G = G::from_u64(187);
-    let __v_28: G = G::from_u64(43);
-    let __v_29: G = G::from_u64(103);
-    let __v_30: G = G::from_u64(146);
-    let __v_31: G = G::from_u64(29);
+    let __v_0: G = G::from_u64(214);
+    let __v_1: G = G::from_u64(246);
+    let __v_2: G = G::from_u64(42);
+    let __v_3: G = G::from_u64(151);
+    let __v_4: G = G::from_u64(121);
+    let __v_5: G = G::from_u64(16);
+    let __v_6: G = G::from_u64(143);
+    let __v_7: G = G::from_u64(159);
+    let __v_8: G = G::from_u64(182);
+    let __v_9: G = G::from_u64(182);
+    let __v_10: G = G::from_u64(107);
+    let __v_11: G = G::from_u64(49);
+    let __v_12: G = G::from_u64(204);
+    let __v_13: G = G::from_u64(148);
+    let __v_14: G = G::from_u64(195);
+    let __v_15: G = G::from_u64(216);
+    let __v_16: G = G::from_u64(76);
+    let __v_17: G = G::from_u64(167);
+    let __v_18: G = G::from_u64(45);
+    let __v_19: G = G::from_u64(139);
+    let __v_20: G = G::from_u64(234);
+    let __v_21: G = G::from_u64(24);
+    let __v_22: G = G::from_u64(94);
+    let __v_23: G = G::from_u64(19);
+    let __v_24: G = G::from_u64(19);
+    let __v_25: G = G::from_u64(124);
+    let __v_26: G = G::from_u64(80);
+    let __v_27: G = G::from_u64(199);
+    let __v_28: G = G::from_u64(239);
+    let __v_29: G = G::from_u64(132);
+    let __v_30: G = G::from_u64(201);
+    let __v_31: G = G::from_u64(105);
     let __v_32: G = { let __values: [G; 32] = [__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]; 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_248] = [__v_32];
-    record.function_queries[248].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_141] = [__v_32];
+    record.function_queries[141].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_249: usize = 0;
-const IN_249: usize = 0;
-const OUT_249: usize = 1;
-fn aiur_fn_249(
-  inp: [G; IN_249],
+const INPUT_SIZE_142: usize = 0;
+const IN_142: usize = 0;
+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_249], ExecError> {
+) -> Result<[G; OUT_142], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(131);
-    let __v_1: G = G::from_u64(253);
-    let __v_2: G = G::from_u64(227);
-    let __v_3: G = G::from_u64(143);
-    let __v_4: G = G::from_u64(170);
-    let __v_5: G = G::from_u64(17);
-    let __v_6: G = G::from_u64(100);
-    let __v_7: G = G::from_u64(100);
-    let __v_8: G = G::from_u64(142);
-    let __v_9: G = G::from_u64(66);
-    let __v_10: G = G::from_u64(39);
-    let __v_11: G = G::from_u64(151);
-    let __v_12: G = G::from_u64(90);
-    let __v_13: G = G::from_u64(191);
-    let __v_14: G = G::from_u64(46);
-    let __v_15: G = G::from_u64(140);
-    let __v_16: G = G::from_u64(38);
-    let __v_17: G = G::from_u64(13);
-    let __v_18: G = G::from_u64(125);
-    let __v_19: G = G::from_u64(78);
-    let __v_20: G = G::from_u64(241);
-    let __v_21: G = G::from_u64(201);
-    let __v_22: G = G::from_u64(38);
-    let __v_23: G = G::from_u64(118);
-    let __v_24: G = G::from_u64(33);
-    let __v_25: G = G::from_u64(79);
-    let __v_26: G = G::from_u64(254);
-    let __v_27: G = G::from_u64(88);
-    let __v_28: G = G::from_u64(38);
-    let __v_29: G = G::from_u64(194);
-    let __v_30: G = G::from_u64(7);
-    let __v_31: G = G::from_u64(93);
+    let __v_0: G = G::from_u64(253);
+    let __v_1: G = G::from_u64(189);
+    let __v_2: G = G::from_u64(95);
+    let __v_3: G = G::from_u64(239);
+    let __v_4: G = G::from_u64(64);
+    let __v_5: G = G::from_u64(20);
+    let __v_6: G = G::from_u64(156);
+    let __v_7: G = G::from_u64(133);
+    let __v_8: G = G::from_u64(51);
+    let __v_9: G = G::from_u64(60);
+    let __v_10: G = G::from_u64(111);
+    let __v_11: G = G::from_u64(60);
+    let __v_12: G = G::from_u64(206);
+    let __v_13: G = G::from_u64(187);
+    let __v_14: G = G::from_u64(75);
+    let __v_15: G = G::from_u64(231);
+    let __v_16: G = G::from_u64(65);
+    let __v_17: G = G::from_u64(39);
+    let __v_18: G = G::from_u64(13);
+    let __v_19: G = G::from_u64(32);
+    let __v_20: G = G::from_u64(102);
+    let __v_21: G = G::from_u64(51);
+    let __v_22: G = G::from_u64(108);
+    let __v_23: G = G::from_u64(178);
+    let __v_24: G = G::from_u64(238);
+    let __v_25: G = G::from_u64(248);
+    let __v_26: G = G::from_u64(118);
+    let __v_27: G = G::from_u64(35);
+    let __v_28: G = G::from_u64(116);
+    let __v_29: G = G::from_u64(75);
+    let __v_30: G = G::from_u64(114);
+    let __v_31: G = G::from_u64(176);
     let __v_32: G = { let __values: [G; 32] = [__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]; 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_249] = [__v_32];
-    record.function_queries[249].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_142] = [__v_32];
+    record.function_queries[142].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_250: usize = 0;
-const IN_250: usize = 0;
-const OUT_250: usize = 1;
-fn aiur_fn_250(
-  inp: [G; IN_250],
+const INPUT_SIZE_143: usize = 0;
+const IN_143: usize = 0;
+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_250], ExecError> {
+) -> Result<[G; OUT_143], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(56);
-    let __v_1: G = G::from_u64(214);
-    let __v_2: G = G::from_u64(15);
-    let __v_3: G = G::from_u64(250);
+    let __v_0: G = G::from_u64(102);
+    let __v_1: G = G::from_u64(73);
+    let __v_2: G = G::from_u64(102);
+    let __v_3: G = G::from_u64(86);
     let __v_4: G = G::from_u64(7);
-    let __v_5: G = G::from_u64(181);
-    let __v_6: G = G::from_u64(6);
-    let __v_7: G = G::from_u64(120);
-    let __v_8: G = G::from_u64(208);
-    let __v_9: G = G::from_u64(195);
-    let __v_10: G = G::from_u64(191);
-    let __v_11: G = G::from_u64(12);
-    let __v_12: G = G::from_u64(6);
-    let __v_13: G = G::from_u64(248);
-    let __v_14: G = G::from_u64(108);
-    let __v_15: G = G::from_u64(215);
-    let __v_16: G = G::from_u64(150);
-    let __v_17: G = G::from_u64(123);
-    let __v_18: G = G::from_u64(53);
-    let __v_19: G = G::from_u64(232);
-    let __v_20: G = G::from_u64(122);
-    let __v_21: G = G::from_u64(176);
-    let __v_22: G = G::from_u64(113);
-    let __v_23: G = G::from_u64(188);
-    let __v_24: G = G::from_u64(85);
-    let __v_25: G = G::from_u64(137);
-    let __v_26: G = G::from_u64(159);
-    let __v_27: G = G::from_u64(203);
-    let __v_28: G = G::from_u64(174);
-    let __v_29: G = G::from_u64(212);
-    let __v_30: G = G::from_u64(116);
-    let __v_31: G = G::from_u64(79);
+    let __v_5: G = G::from_u64(176);
+    let __v_6: G = G::from_u64(117);
+    let __v_7: G = G::from_u64(12);
+    let __v_8: G = G::from_u64(44);
+    let __v_9: G = G::from_u64(167);
+    let __v_10: G = G::from_u64(63);
+    let __v_11: G = G::from_u64(69);
+    let __v_12: G = G::from_u64(222);
+    let __v_13: G = G::from_u64(96);
+    let __v_14: G = G::from_u64(15);
+    let __v_15: G = G::from_u64(33);
+    let __v_16: G = G::from_u64(203);
+    let __v_17: G = G::from_u64(103);
+    let __v_18: G = G::from_u64(3);
+    let __v_19: G = G::from_u64(152);
+    let __v_20: G = G::from_u64(80);
+    let __v_21: G = G::from_u64(72);
+    let __v_22: G = G::from_u64(101);
+    let __v_23: G = G::from_u64(187);
+    let __v_24: G = G::from_u64(151);
+    let __v_25: G = G::from_u64(151);
+    let __v_26: G = G::from_u64(36);
+    let __v_27: G = G::from_u64(56);
+    let __v_28: G = G::from_u64(1);
+    let __v_29: G = G::from_u64(79);
+    let __v_30: G = G::from_u64(150);
+    let __v_31: G = G::from_u64(217);
     let __v_32: G = { let __values: [G; 32] = [__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]; 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_250] = [__v_32];
-    record.function_queries[250].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_143] = [__v_32];
+    record.function_queries[143].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_251: usize = 0;
-const IN_251: usize = 0;
-const OUT_251: usize = 1;
-fn aiur_fn_251(
-  inp: [G; IN_251],
+const INPUT_SIZE_144: usize = 0;
+const IN_144: usize = 0;
+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_251], ExecError> {
+) -> Result<[G; OUT_144], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(85);
-    let __v_1: G = G::from_u64(104);
-    let __v_2: G = G::from_u64(231);
-    let __v_3: G = G::from_u64(153);
-    let __v_4: G = G::from_u64(25);
-    let __v_5: G = G::from_u64(141);
-    let __v_6: G = G::from_u64(173);
-    let __v_7: G = G::from_u64(159);
-    let __v_8: G = G::from_u64(171);
-    let __v_9: G = G::from_u64(14);
-    let __v_10: G = G::from_u64(120);
-    let __v_11: G = G::from_u64(75);
-    let __v_12: G = G::from_u64(122);
-    let __v_13: G = G::from_u64(76);
-    let __v_14: G = G::from_u64(88);
-    let __v_15: G = G::from_u64(17);
-    let __v_16: G = G::from_u64(43);
-    let __v_17: G = G::from_u64(252);
-    let __v_18: G = G::from_u64(38);
-    let __v_19: G = G::from_u64(136);
-    let __v_20: G = G::from_u64(174);
-    let __v_21: G = G::from_u64(206);
-    let __v_22: G = G::from_u64(190);
-    let __v_23: G = G::from_u64(60);
-    let __v_24: G = G::from_u64(44);
-    let __v_25: G = G::from_u64(101);
-    let __v_26: G = G::from_u64(99);
-    let __v_27: G = G::from_u64(48);
-    let __v_28: G = G::from_u64(66);
-    let __v_29: G = G::from_u64(16);
-    let __v_30: G = G::from_u64(249);
-    let __v_31: G = G::from_u64(86);
+    let __v_0: G = G::from_u64(51);
+    let __v_1: G = G::from_u64(198);
+    let __v_2: G = G::from_u64(4);
+    let __v_3: G = G::from_u64(69);
+    let __v_4: G = G::from_u64(29);
+    let __v_5: G = G::from_u64(1);
+    let __v_6: G = G::from_u64(203);
+    let __v_7: G = G::from_u64(25);
+    let __v_8: G = G::from_u64(164);
+    let __v_9: G = G::from_u64(51);
+    let __v_10: G = G::from_u64(102);
+    let __v_11: G = G::from_u64(130);
+    let __v_12: G = G::from_u64(70);
+    let __v_13: G = G::from_u64(185);
+    let __v_14: G = G::from_u64(143);
+    let __v_15: G = G::from_u64(110);
+    let __v_16: G = G::from_u64(135);
+    let __v_17: G = G::from_u64(75);
+    let __v_18: G = G::from_u64(214);
+    let __v_19: G = G::from_u64(48);
+    let __v_20: G = G::from_u64(183);
+    let __v_21: G = G::from_u64(138);
+    let __v_22: G = G::from_u64(121);
+    let __v_23: G = G::from_u64(29);
+    let __v_24: G = G::from_u64(122);
+    let __v_25: G = G::from_u64(55);
+    let __v_26: G = G::from_u64(58);
+    let __v_27: G = G::from_u64(151);
+    let __v_28: G = G::from_u64(152);
+    let __v_29: G = G::from_u64(73);
+    let __v_30: G = G::from_u64(161);
+    let __v_31: G = G::from_u64(207);
     let __v_32: G = { let __values: [G; 32] = [__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]; 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_251] = [__v_32];
-    record.function_queries[251].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_144] = [__v_32];
+    record.function_queries[144].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_252: usize = 0;
-const IN_252: usize = 0;
-const OUT_252: usize = 1;
-fn aiur_fn_252(
-  inp: [G; IN_252],
+const INPUT_SIZE_145: usize = 0;
+const IN_145: usize = 0;
+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_252], ExecError> {
+) -> Result<[G; OUT_145], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(9);
-    let __v_1: G = G::from_u64(188);
-    let __v_2: G = G::from_u64(37);
-    let __v_3: G = G::from_u64(49);
-    let __v_4: G = G::from_u64(71);
-    let __v_5: G = G::from_u64(195);
-    let __v_6: G = G::from_u64(108);
-    let __v_7: G = G::from_u64(226);
-    let __v_8: G = G::from_u64(44);
-    let __v_9: G = G::from_u64(142);
-    let __v_10: G = G::from_u64(12);
-    let __v_11: G = G::from_u64(205);
-    let __v_12: G = G::from_u64(67);
-    let __v_13: G = G::from_u64(199);
-    let __v_14: G = G::from_u64(155);
-    let __v_15: G = G::from_u64(44);
-    let __v_16: G = G::from_u64(218);
-    let __v_17: G = G::from_u64(226);
-    let __v_18: G = G::from_u64(32);
-    let __v_19: G = G::from_u64(110);
-    let __v_20: G = G::from_u64(13);
-    let __v_21: G = G::from_u64(221);
-    let __v_22: G = G::from_u64(22);
-    let __v_23: G = G::from_u64(143);
-    let __v_24: G = G::from_u64(202);
-    let __v_25: G = G::from_u64(54);
-    let __v_26: G = G::from_u64(9);
-    let __v_27: G = G::from_u64(178);
-    let __v_28: G = G::from_u64(165);
-    let __v_29: G = G::from_u64(132);
-    let __v_30: G = G::from_u64(211);
-    let __v_31: G = G::from_u64(220);
+    let __v_0: G = G::from_u64(59);
+    let __v_1: G = G::from_u64(228);
+    let __v_2: G = G::from_u64(131);
+    let __v_3: G = G::from_u64(87);
+    let __v_4: G = G::from_u64(174);
+    let __v_5: G = G::from_u64(23);
+    let __v_6: G = G::from_u64(247);
+    let __v_7: G = G::from_u64(77);
+    let __v_8: G = G::from_u64(77);
+    let __v_9: G = G::from_u64(242);
+    let __v_10: G = G::from_u64(125);
+    let __v_11: G = G::from_u64(105);
+    let __v_12: G = G::from_u64(122);
+    let __v_13: G = G::from_u64(237);
+    let __v_14: G = G::from_u64(63);
+    let __v_15: G = G::from_u64(71);
+    let __v_16: G = G::from_u64(193);
+    let __v_17: G = G::from_u64(48);
+    let __v_18: G = G::from_u64(121);
+    let __v_19: G = G::from_u64(65);
+    let __v_20: G = G::from_u64(244);
+    let __v_21: G = G::from_u64(26);
+    let __v_22: G = G::from_u64(255);
+    let __v_23: G = G::from_u64(207);
+    let __v_24: G = G::from_u64(116);
+    let __v_25: G = G::from_u64(218);
+    let __v_26: G = G::from_u64(95);
+    let __v_27: G = G::from_u64(102);
+    let __v_28: G = G::from_u64(213);
+    let __v_29: G = G::from_u64(17);
+    let __v_30: G = G::from_u64(167);
+    let __v_31: G = G::from_u64(151);
     let __v_32: G = { let __values: [G; 32] = [__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]; 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_252] = [__v_32];
-    record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_145] = [__v_32];
+    record.function_queries[145].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_253: usize = 0;
-const IN_253: usize = 0;
-const OUT_253: usize = 1;
-fn aiur_fn_253(
-  inp: [G; IN_253],
+const INPUT_SIZE_146: usize = 0;
+const IN_146: usize = 0;
+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_253], ExecError> {
+) -> Result<[G; OUT_146], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(38);
-    let __v_1: G = G::from_u64(124);
-    let __v_2: G = G::from_u64(10);
-    let __v_3: G = G::from_u64(156);
-    let __v_4: G = G::from_u64(146);
-    let __v_5: G = G::from_u64(231);
-    let __v_6: G = G::from_u64(86);
-    let __v_7: G = G::from_u64(56);
-    let __v_8: G = G::from_u64(252);
-    let __v_9: G = G::from_u64(115);
-    let __v_10: G = G::from_u64(237);
-    let __v_11: G = G::from_u64(82);
-    let __v_12: G = G::from_u64(169);
-    let __v_13: G = G::from_u64(249);
-    let __v_14: G = G::from_u64(200);
-    let __v_15: G = G::from_u64(22);
-    let __v_16: G = G::from_u64(71);
-    let __v_17: G = G::from_u64(238);
-    let __v_18: G = G::from_u64(236);
-    let __v_19: G = G::from_u64(238);
-    let __v_20: G = G::from_u64(255);
-    let __v_21: G = G::from_u64(33);
-    let __v_22: G = G::from_u64(68);
-    let __v_23: G = G::from_u64(193);
-    let __v_24: G = G::from_u64(249);
-    let __v_25: G = G::from_u64(126);
-    let __v_26: G = G::from_u64(101);
-    let __v_27: G = G::from_u64(226);
-    let __v_28: G = G::from_u64(175);
-    let __v_29: G = G::from_u64(241);
-    let __v_30: G = G::from_u64(73);
-    let __v_31: G = G::from_u64(241);
+    let __v_0: G = G::from_u64(81);
+    let __v_1: G = G::from_u64(121);
+    let __v_2: G = G::from_u64(99);
+    let __v_3: G = G::from_u64(139);
+    let __v_4: G = G::from_u64(130);
+    let __v_5: G = G::from_u64(204);
+    let __v_6: G = G::from_u64(131);
+    let __v_7: G = G::from_u64(55);
+    let __v_8: G = G::from_u64(145);
+    let __v_9: G = G::from_u64(74);
+    let __v_10: G = G::from_u64(123);
+    let __v_11: G = G::from_u64(202);
+    let __v_12: G = G::from_u64(173);
+    let __v_13: G = G::from_u64(133);
+    let __v_14: G = G::from_u64(140);
+    let __v_15: G = G::from_u64(133);
+    let __v_16: G = G::from_u64(136);
+    let __v_17: G = G::from_u64(136);
+    let __v_18: G = G::from_u64(68);
+    let __v_19: G = G::from_u64(233);
+    let __v_20: G = G::from_u64(162);
+    let __v_21: G = G::from_u64(146);
+    let __v_22: G = G::from_u64(67);
+    let __v_23: G = G::from_u64(12);
+    let __v_24: G = G::from_u64(172);
+    let __v_25: G = G::from_u64(81);
+    let __v_26: G = G::from_u64(229);
+    let __v_27: G = G::from_u64(234);
+    let __v_28: G = G::from_u64(220);
+    let __v_29: G = G::from_u64(65);
+    let __v_30: G = G::from_u64(161);
+    let __v_31: G = G::from_u64(175);
     let __v_32: G = { let __values: [G; 32] = [__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]; 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_253] = [__v_32];
-    record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_146] = [__v_32];
+    record.function_queries[146].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_254: usize = 0;
-const IN_254: usize = 0;
-const OUT_254: usize = 1;
-fn aiur_fn_254(
-  inp: [G; IN_254],
+const INPUT_SIZE_147: usize = 0;
+const IN_147: usize = 0;
+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_254], ExecError> {
+) -> Result<[G; OUT_147], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(116);
-    let __v_1: G = G::from_u64(89);
-    let __v_2: G = G::from_u64(54);
-    let __v_3: G = G::from_u64(252);
-    let __v_4: G = G::from_u64(185);
-    let __v_5: G = G::from_u64(216);
-    let __v_6: G = G::from_u64(108);
-    let __v_7: G = G::from_u64(68);
-    let __v_8: G = G::from_u64(87);
-    let __v_9: G = G::from_u64(240);
-    let __v_10: G = G::from_u64(253);
-    let __v_11: G = G::from_u64(30);
-    let __v_12: G = G::from_u64(83);
-    let __v_13: G = G::from_u64(126);
-    let __v_14: G = G::from_u64(103);
-    let __v_15: G = G::from_u64(7);
-    let __v_16: G = G::from_u64(127);
-    let __v_17: G = G::from_u64(70);
-    let __v_18: G = G::from_u64(247);
-    let __v_19: G = G::from_u64(132);
-    let __v_20: G = G::from_u64(17);
-    let __v_21: G = G::from_u64(8);
-    let __v_22: G = G::from_u64(65);
-    let __v_23: G = G::from_u64(157);
-    let __v_24: G = G::from_u64(172);
-    let __v_25: G = G::from_u64(121);
-    let __v_26: G = G::from_u64(132);
-    let __v_27: G = G::from_u64(0);
-    let __v_28: G = G::from_u64(139);
-    let __v_29: G = G::from_u64(86);
-    let __v_30: G = G::from_u64(91);
-    let __v_31: G = G::from_u64(151);
+    let __v_0: G = G::from_u64(137);
+    let __v_1: G = G::from_u64(222);
+    let __v_2: G = G::from_u64(202);
+    let __v_3: G = G::from_u64(134);
+    let __v_4: G = G::from_u64(221);
+    let __v_5: G = G::from_u64(143);
+    let __v_6: G = G::from_u64(0);
+    let __v_7: G = G::from_u64(102);
+    let __v_8: G = G::from_u64(165);
+    let __v_9: G = G::from_u64(6);
+    let __v_10: G = G::from_u64(79);
+    let __v_11: G = G::from_u64(219);
+    let __v_12: G = G::from_u64(25);
+    let __v_13: G = G::from_u64(162);
+    let __v_14: G = G::from_u64(198);
+    let __v_15: G = G::from_u64(137);
+    let __v_16: G = G::from_u64(122);
+    let __v_17: G = G::from_u64(58);
+    let __v_18: G = G::from_u64(152);
+    let __v_19: G = G::from_u64(103);
+    let __v_20: G = G::from_u64(202);
+    let __v_21: G = G::from_u64(173);
+    let __v_22: G = G::from_u64(192);
+    let __v_23: G = G::from_u64(79);
+    let __v_24: G = G::from_u64(119);
+    let __v_25: G = G::from_u64(141);
+    let __v_26: G = G::from_u64(92);
+    let __v_27: G = G::from_u64(92);
+    let __v_28: G = G::from_u64(208);
+    let __v_29: G = G::from_u64(34);
+    let __v_30: G = G::from_u64(83);
+    let __v_31: G = G::from_u64(98);
     let __v_32: G = { let __values: [G; 32] = [__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]; 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_254] = [__v_32];
-    record.function_queries[254].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_147] = [__v_32];
+    record.function_queries[147].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_255: usize = 0;
-const IN_255: usize = 0;
-const OUT_255: usize = 1;
-fn aiur_fn_255(
-  inp: [G; IN_255],
+const INPUT_SIZE_148: usize = 0;
+const IN_148: usize = 0;
+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_255], ExecError> {
+) -> Result<[G; OUT_148], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(171);
-    let __v_1: G = G::from_u64(55);
-    let __v_2: G = G::from_u64(118);
-    let __v_3: G = G::from_u64(152);
-    let __v_4: G = G::from_u64(87);
-    let __v_5: G = G::from_u64(67);
-    let __v_6: G = G::from_u64(175);
-    let __v_7: G = G::from_u64(19);
-    let __v_8: G = G::from_u64(169);
-    let __v_9: G = G::from_u64(203);
-    let __v_10: G = G::from_u64(26);
-    let __v_11: G = G::from_u64(125);
-    let __v_12: G = G::from_u64(47);
-    let __v_13: G = G::from_u64(132);
-    let __v_14: G = G::from_u64(150);
-    let __v_15: G = G::from_u64(153);
-    let __v_16: G = G::from_u64(120);
-    let __v_17: G = G::from_u64(146);
-    let __v_18: G = G::from_u64(225);
-    let __v_19: G = G::from_u64(121);
-    let __v_20: G = G::from_u64(131);
-    let __v_21: G = G::from_u64(209);
-    let __v_22: G = G::from_u64(75);
-    let __v_23: G = G::from_u64(229);
-    let __v_24: G = G::from_u64(39);
-    let __v_25: G = G::from_u64(10);
-    let __v_26: G = G::from_u64(113);
-    let __v_27: G = G::from_u64(101);
-    let __v_28: G = G::from_u64(112);
-    let __v_29: G = G::from_u64(179);
-    let __v_30: G = G::from_u64(87);
-    let __v_31: G = G::from_u64(25);
+    let __v_0: G = G::from_u64(129);
+    let __v_1: G = G::from_u64(138);
+    let __v_2: G = G::from_u64(187);
+    let __v_3: G = G::from_u64(51);
+    let __v_4: G = G::from_u64(17);
+    let __v_5: G = G::from_u64(80);
+    let __v_6: G = G::from_u64(64);
+    let __v_7: G = G::from_u64(13);
+    let __v_8: G = G::from_u64(16);
+    let __v_9: G = G::from_u64(179);
+    let __v_10: G = G::from_u64(79);
+    let __v_11: G = G::from_u64(174);
+    let __v_12: G = G::from_u64(77);
+    let __v_13: G = G::from_u64(251);
+    let __v_14: G = G::from_u64(148);
+    let __v_15: G = G::from_u64(38);
+    let __v_16: G = G::from_u64(116);
+    let __v_17: G = G::from_u64(28);
+    let __v_18: G = G::from_u64(70);
+    let __v_19: G = G::from_u64(7);
+    let __v_20: G = G::from_u64(186);
+    let __v_21: G = G::from_u64(238);
+    let __v_22: G = G::from_u64(216);
+    let __v_23: G = G::from_u64(217);
+    let __v_24: G = G::from_u64(98);
+    let __v_25: G = G::from_u64(113);
+    let __v_26: G = G::from_u64(186);
+    let __v_27: G = G::from_u64(22);
+    let __v_28: G = G::from_u64(89);
+    let __v_29: G = G::from_u64(5);
+    let __v_30: G = G::from_u64(142);
+    let __v_31: G = G::from_u64(248);
     let __v_32: G = { let __values: [G; 32] = [__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]; 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_255] = [__v_32];
-    record.function_queries[255].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_148] = [__v_32];
+    record.function_queries[148].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_256: usize = 0;
-const IN_256: usize = 0;
-const OUT_256: usize = 1;
-fn aiur_fn_256(
-  inp: [G; IN_256],
+const INPUT_SIZE_149: usize = 0;
+const IN_149: usize = 0;
+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_256], ExecError> {
+) -> Result<[G; OUT_149], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(15);
-    let __v_1: G = G::from_u64(158);
-    let __v_2: G = G::from_u64(232);
-    let __v_3: G = G::from_u64(217);
-    let __v_4: G = G::from_u64(3);
-    let __v_5: G = G::from_u64(61);
-    let __v_6: G = G::from_u64(143);
-    let __v_7: G = G::from_u64(123);
-    let __v_8: G = G::from_u64(133);
-    let __v_9: G = G::from_u64(47);
-    let __v_10: G = G::from_u64(91);
-    let __v_11: G = G::from_u64(113);
-    let __v_12: G = G::from_u64(82);
-    let __v_13: G = G::from_u64(253);
-    let __v_14: G = G::from_u64(18);
-    let __v_15: G = G::from_u64(79);
-    let __v_16: G = G::from_u64(125);
-    let __v_17: G = G::from_u64(65);
-    let __v_18: G = G::from_u64(25);
-    let __v_19: G = G::from_u64(48);
-    let __v_20: G = G::from_u64(201);
-    let __v_21: G = G::from_u64(146);
-    let __v_22: G = G::from_u64(224);
-    let __v_23: G = G::from_u64(244);
-    let __v_24: G = G::from_u64(87);
-    let __v_25: G = G::from_u64(248);
-    let __v_26: G = G::from_u64(16);
-    let __v_27: G = G::from_u64(75);
-    let __v_28: G = G::from_u64(96);
-    let __v_29: G = G::from_u64(169);
-    let __v_30: G = G::from_u64(131);
-    let __v_31: G = G::from_u64(129);
+    let __v_0: G = G::from_u64(155);
+    let __v_1: G = G::from_u64(118);
+    let __v_2: G = G::from_u64(243);
+    let __v_3: G = G::from_u64(43);
+    let __v_4: G = G::from_u64(187);
+    let __v_5: G = G::from_u64(29);
+    let __v_6: G = G::from_u64(189);
+    let __v_7: G = G::from_u64(244);
+    let __v_8: G = G::from_u64(255);
+    let __v_9: G = G::from_u64(104);
+    let __v_10: G = G::from_u64(224);
+    let __v_11: G = G::from_u64(34);
+    let __v_12: G = G::from_u64(18);
+    let __v_13: G = G::from_u64(37);
+    let __v_14: G = G::from_u64(1);
+    let __v_15: G = G::from_u64(93);
+    let __v_16: G = G::from_u64(240);
+    let __v_17: G = G::from_u64(202);
+    let __v_18: G = G::from_u64(45);
+    let __v_19: G = G::from_u64(42);
+    let __v_20: G = G::from_u64(96);
+    let __v_21: G = G::from_u64(35);
+    let __v_22: G = G::from_u64(193);
+    let __v_23: G = G::from_u64(168);
+    let __v_24: G = G::from_u64(19);
+    let __v_25: G = G::from_u64(6);
+    let __v_26: G = G::from_u64(212);
+    let __v_27: G = G::from_u64(2);
+    let __v_28: G = G::from_u64(13);
+    let __v_29: G = G::from_u64(78);
+    let __v_30: G = G::from_u64(243);
+    let __v_31: G = G::from_u64(151);
     let __v_32: G = { let __values: [G; 32] = [__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]; 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_256] = [__v_32];
-    record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_149] = [__v_32];
+    record.function_queries[149].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_257: usize = 0;
-const IN_257: usize = 0;
-const OUT_257: usize = 1;
-fn aiur_fn_257(
-  inp: [G; IN_257],
+const INPUT_SIZE_150: usize = 0;
+const IN_150: usize = 0;
+const OUT_150: usize = 1;
+fn aiur_fn_150(
+  inp: [G; IN_150],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_257], ExecError> {
+) -> Result<[G; OUT_150], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(4);
-    let __v_1: G = G::from_u64(113);
-    let __v_2: G = G::from_u64(228);
-    let __v_3: G = G::from_u64(113);
-    let __v_4: G = G::from_u64(88);
-    let __v_5: G = G::from_u64(178);
-    let __v_6: G = G::from_u64(174);
-    let __v_7: G = G::from_u64(24);
-    let __v_8: G = G::from_u64(211);
-    let __v_9: G = G::from_u64(192);
-    let __v_10: G = G::from_u64(141);
-    let __v_11: G = G::from_u64(213);
-    let __v_12: G = G::from_u64(199);
-    let __v_13: G = G::from_u64(122);
-    let __v_14: G = G::from_u64(174);
-    let __v_15: G = G::from_u64(35);
-    let __v_16: G = G::from_u64(230);
-    let __v_17: G = G::from_u64(45);
-    let __v_18: G = G::from_u64(123);
-    let __v_19: G = G::from_u64(188);
-    let __v_20: G = G::from_u64(30);
-    let __v_21: G = G::from_u64(97);
-    let __v_22: G = G::from_u64(17);
-    let __v_23: G = G::from_u64(107);
-    let __v_24: G = G::from_u64(194);
-    let __v_25: G = G::from_u64(129);
-    let __v_26: G = G::from_u64(59);
-    let __v_27: G = G::from_u64(19);
-    let __v_28: G = G::from_u64(6);
-    let __v_29: G = G::from_u64(188);
-    let __v_30: G = G::from_u64(87);
-    let __v_31: G = G::from_u64(149);
+    let __v_0: G = G::from_u64(151);
+    let __v_1: G = G::from_u64(227);
+    let __v_2: G = G::from_u64(37);
+    let __v_3: G = G::from_u64(169);
+    let __v_4: G = G::from_u64(106);
+    let __v_5: G = G::from_u64(106);
+    let __v_6: G = G::from_u64(24);
+    let __v_7: G = G::from_u64(39);
+    let __v_8: G = G::from_u64(25);
+    let __v_9: G = G::from_u64(78);
+    let __v_10: G = G::from_u64(235);
+    let __v_11: G = G::from_u64(125);
+    let __v_12: G = G::from_u64(42);
+    let __v_13: G = G::from_u64(160);
+    let __v_14: G = G::from_u64(217);
+    let __v_15: G = G::from_u64(25);
+    let __v_16: G = G::from_u64(33);
+    let __v_17: G = G::from_u64(7);
+    let __v_18: G = G::from_u64(58);
+    let __v_19: G = G::from_u64(239);
+    let __v_20: G = G::from_u64(156);
+    let __v_21: G = G::from_u64(45);
+    let __v_22: G = G::from_u64(51);
+    let __v_23: G = G::from_u64(60);
+    let __v_24: G = G::from_u64(36);
+    let __v_25: G = G::from_u64(97);
+    let __v_26: G = G::from_u64(62);
+    let __v_27: G = G::from_u64(154);
+    let __v_28: G = G::from_u64(201);
+    let __v_29: G = G::from_u64(86);
+    let __v_30: G = G::from_u64(237);
+    let __v_31: G = G::from_u64(41);
     let __v_32: G = { let __values: [G; 32] = [__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]; 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_257] = [__v_32];
-    record.function_queries[257].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_150] = [__v_32];
+    record.function_queries[150].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_258: usize = 0;
-const IN_258: usize = 0;
-const OUT_258: usize = 1;
-fn aiur_fn_258(
-  inp: [G; IN_258],
+const INPUT_SIZE_151: usize = 0;
+const IN_151: usize = 0;
+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_258], ExecError> {
+) -> Result<[G; OUT_151], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(33);
-    let __v_1: G = G::from_u64(224);
-    let __v_2: G = G::from_u64(224);
-    let __v_3: G = G::from_u64(120);
-    let __v_4: G = G::from_u64(59);
-    let __v_5: G = G::from_u64(118);
-    let __v_6: G = G::from_u64(23);
-    let __v_7: G = G::from_u64(176);
-    let __v_8: G = G::from_u64(204);
-    let __v_9: G = G::from_u64(78);
-    let __v_10: G = G::from_u64(255);
-    let __v_11: G = G::from_u64(77);
-    let __v_12: G = G::from_u64(31);
-    let __v_13: G = G::from_u64(171);
-    let __v_14: G = G::from_u64(124);
-    let __v_15: G = G::from_u64(255);
-    let __v_16: G = G::from_u64(239);
-    let __v_17: G = G::from_u64(224);
-    let __v_18: G = G::from_u64(28);
-    let __v_19: G = G::from_u64(212);
-    let __v_20: G = G::from_u64(61);
-    let __v_21: G = G::from_u64(167);
-    let __v_22: G = G::from_u64(126);
-    let __v_23: G = G::from_u64(47);
-    let __v_24: G = G::from_u64(152);
-    let __v_25: G = G::from_u64(209);
-    let __v_26: G = G::from_u64(80);
-    let __v_27: G = G::from_u64(148);
-    let __v_28: G = G::from_u64(160);
-    let __v_29: G = G::from_u64(216);
-    let __v_30: G = G::from_u64(240);
-    let __v_31: G = G::from_u64(134);
+    let __v_0: G = G::from_u64(220);
+    let __v_1: G = G::from_u64(129);
+    let __v_2: G = G::from_u64(228);
+    let __v_3: G = G::from_u64(28);
+    let __v_4: G = G::from_u64(173);
+    let __v_5: G = G::from_u64(17);
+    let __v_6: G = G::from_u64(144);
+    let __v_7: G = G::from_u64(55);
+    let __v_8: G = G::from_u64(125);
+    let __v_9: G = G::from_u64(190);
+    let __v_10: G = G::from_u64(96);
+    let __v_11: G = G::from_u64(75);
+    let __v_12: G = G::from_u64(252);
+    let __v_13: G = G::from_u64(58);
+    let __v_14: G = G::from_u64(254);
+    let __v_15: G = G::from_u64(101);
+    let __v_16: G = G::from_u64(138);
+    let __v_17: G = G::from_u64(65);
+    let __v_18: G = G::from_u64(59);
+    let __v_19: G = G::from_u64(154);
+    let __v_20: G = G::from_u64(45);
+    let __v_21: G = G::from_u64(207);
+    let __v_22: G = G::from_u64(188);
+    let __v_23: G = G::from_u64(171);
+    let __v_24: G = G::from_u64(121);
+    let __v_25: G = G::from_u64(250);
+    let __v_26: G = G::from_u64(215);
+    let __v_27: G = G::from_u64(183);
+    let __v_28: G = G::from_u64(165);
+    let __v_29: G = G::from_u64(205);
+    let __v_30: G = G::from_u64(217);
+    let __v_31: G = G::from_u64(84);
     let __v_32: G = { let __values: [G; 32] = [__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]; 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_258] = [__v_32];
-    record.function_queries[258].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_151] = [__v_32];
+    record.function_queries[151].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_259: usize = 0;
-const IN_259: usize = 0;
-const OUT_259: usize = 1;
-fn aiur_fn_259(
-  inp: [G; IN_259],
+const INPUT_SIZE_152: usize = 0;
+const IN_152: usize = 0;
+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_259], ExecError> {
+) -> Result<[G; OUT_152], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(1);
-    let __v_1: G = G::from_u64(131);
-    let __v_2: G = G::from_u64(89);
-    let __v_3: G = G::from_u64(91);
-    let __v_4: G = G::from_u64(131);
-    let __v_5: G = G::from_u64(123);
-    let __v_6: G = G::from_u64(155);
-    let __v_7: G = G::from_u64(132);
-    let __v_8: G = G::from_u64(218);
-    let __v_9: G = G::from_u64(95);
-    let __v_10: G = G::from_u64(0);
-    let __v_11: G = G::from_u64(75);
-    let __v_12: G = G::from_u64(138);
-    let __v_13: G = G::from_u64(196);
-    let __v_14: G = G::from_u64(164);
-    let __v_15: G = G::from_u64(187);
-    let __v_16: G = G::from_u64(211);
-    let __v_17: G = G::from_u64(188);
-    let __v_18: G = G::from_u64(6);
-    let __v_19: G = G::from_u64(40);
-    let __v_20: G = G::from_u64(185);
-    let __v_21: G = G::from_u64(156);
-    let __v_22: G = G::from_u64(141);
-    let __v_23: G = G::from_u64(85);
-    let __v_24: G = G::from_u64(14);
-    let __v_25: G = G::from_u64(179);
-    let __v_26: G = G::from_u64(81);
-    let __v_27: G = G::from_u64(247);
-    let __v_28: G = G::from_u64(76);
-    let __v_29: G = G::from_u64(225);
-    let __v_30: G = G::from_u64(109);
-    let __v_31: G = G::from_u64(72);
+    let __v_0: G = G::from_u64(109);
+    let __v_1: G = G::from_u64(180);
+    let __v_2: G = G::from_u64(147);
+    let __v_3: G = G::from_u64(4);
+    let __v_4: G = G::from_u64(191);
+    let __v_5: G = G::from_u64(15);
+    let __v_6: G = G::from_u64(90);
+    let __v_7: G = G::from_u64(203);
+    let __v_8: G = G::from_u64(253);
+    let __v_9: G = G::from_u64(29);
+    let __v_10: G = G::from_u64(157);
+    let __v_11: G = G::from_u64(154);
+    let __v_12: G = G::from_u64(12);
+    let __v_13: G = G::from_u64(27);
+    let __v_14: G = G::from_u64(122);
+    let __v_15: G = G::from_u64(226);
+    let __v_16: G = G::from_u64(14);
+    let __v_17: G = G::from_u64(249);
+    let __v_18: G = G::from_u64(157);
+    let __v_19: G = G::from_u64(7);
+    let __v_20: G = G::from_u64(55);
+    let __v_21: G = G::from_u64(136);
+    let __v_22: G = G::from_u64(112);
+    let __v_23: G = G::from_u64(86);
+    let __v_24: G = G::from_u64(18);
+    let __v_25: G = G::from_u64(159);
+    let __v_26: G = G::from_u64(91);
+    let __v_27: G = G::from_u64(92);
+    let __v_28: G = G::from_u64(181);
+    let __v_29: G = G::from_u64(169);
+    let __v_30: G = G::from_u64(186);
+    let __v_31: G = G::from_u64(138);
     let __v_32: G = { let __values: [G; 32] = [__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]; 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_259] = [__v_32];
-    record.function_queries[259].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_152] = [__v_32];
+    record.function_queries[152].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_260: usize = 0;
-const IN_260: usize = 0;
-const OUT_260: usize = 1;
-fn aiur_fn_260(
-  inp: [G; IN_260],
+const INPUT_SIZE_153: usize = 0;
+const IN_153: usize = 0;
+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_260], ExecError> {
+) -> Result<[G; OUT_153], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(156);
-    let __v_1: G = G::from_u64(230);
-    let __v_2: G = G::from_u64(227);
-    let __v_3: G = G::from_u64(34);
-    let __v_4: G = G::from_u64(241);
-    let __v_5: G = G::from_u64(148);
-    let __v_6: G = G::from_u64(129);
-    let __v_7: G = G::from_u64(242);
-    let __v_8: G = G::from_u64(28);
-    let __v_9: G = G::from_u64(244);
-    let __v_10: G = G::from_u64(196);
-    let __v_11: G = G::from_u64(143);
-    let __v_12: G = G::from_u64(136);
-    let __v_13: G = G::from_u64(120);
-    let __v_14: G = G::from_u64(152);
-    let __v_15: G = G::from_u64(118);
-    let __v_16: G = G::from_u64(182);
-    let __v_17: G = G::from_u64(155);
-    let __v_18: G = G::from_u64(138);
-    let __v_19: G = G::from_u64(155);
-    let __v_20: G = G::from_u64(21);
-    let __v_21: G = G::from_u64(32);
-    let __v_22: G = G::from_u64(67);
-    let __v_23: G = G::from_u64(156);
-    let __v_24: G = G::from_u64(16);
-    let __v_25: G = G::from_u64(29);
-    let __v_26: G = G::from_u64(152);
-    let __v_27: G = G::from_u64(63);
-    let __v_28: G = G::from_u64(150);
-    let __v_29: G = G::from_u64(234);
-    let __v_30: G = G::from_u64(96);
-    let __v_31: G = G::from_u64(183);
+    let __v_0: G = G::from_u64(163);
+    let __v_1: G = G::from_u64(74);
+    let __v_2: G = G::from_u64(178);
+    let __v_3: G = G::from_u64(218);
+    let __v_4: G = G::from_u64(186);
+    let __v_5: G = G::from_u64(52);
+    let __v_6: G = G::from_u64(131);
+    let __v_7: G = G::from_u64(158);
+    let __v_8: G = G::from_u64(133);
+    let __v_9: G = G::from_u64(31);
+    let __v_10: G = G::from_u64(163);
+    let __v_11: G = G::from_u64(103);
+    let __v_12: G = G::from_u64(81);
+    let __v_13: G = G::from_u64(36);
+    let __v_14: G = G::from_u64(86);
+    let __v_15: G = G::from_u64(111);
+    let __v_16: G = G::from_u64(159);
+    let __v_17: G = G::from_u64(77);
+    let __v_18: G = G::from_u64(205);
+    let __v_19: G = G::from_u64(229);
+    let __v_20: G = G::from_u64(151);
+    let __v_21: G = G::from_u64(52);
+    let __v_22: G = G::from_u64(158);
+    let __v_23: G = G::from_u64(205);
+    let __v_24: G = G::from_u64(84);
+    let __v_25: G = G::from_u64(174);
+    let __v_26: G = G::from_u64(50);
+    let __v_27: G = G::from_u64(248);
+    let __v_28: G = G::from_u64(66);
+    let __v_29: G = G::from_u64(78);
+    let __v_30: G = G::from_u64(68);
+    let __v_31: G = G::from_u64(184);
     let __v_32: G = { let __values: [G; 32] = [__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]; 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_260] = [__v_32];
-    record.function_queries[260].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_153] = [__v_32];
+    record.function_queries[153].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_261: usize = 0;
-const IN_261: usize = 0;
-const OUT_261: usize = 1;
-fn aiur_fn_261(
-  inp: [G; IN_261],
+const INPUT_SIZE_154: usize = 0;
+const IN_154: usize = 0;
+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_261], ExecError> {
+) -> Result<[G; OUT_154], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(60);
-    let __v_1: G = G::from_u64(245);
-    let __v_2: G = G::from_u64(77);
-    let __v_3: G = G::from_u64(51);
-    let __v_4: G = G::from_u64(56);
-    let __v_5: G = G::from_u64(33);
-    let __v_6: G = G::from_u64(221);
-    let __v_7: G = G::from_u64(55);
-    let __v_8: G = G::from_u64(104);
-    let __v_9: G = G::from_u64(58);
-    let __v_10: G = G::from_u64(11);
-    let __v_11: G = G::from_u64(243);
-    let __v_12: G = G::from_u64(135);
-    let __v_13: G = G::from_u64(57);
-    let __v_14: G = G::from_u64(230);
-    let __v_15: G = G::from_u64(135);
-    let __v_16: G = G::from_u64(97);
-    let __v_17: G = G::from_u64(10);
-    let __v_18: G = G::from_u64(25);
-    let __v_19: G = G::from_u64(145);
-    let __v_20: G = G::from_u64(117);
-    let __v_21: G = G::from_u64(146);
-    let __v_22: G = G::from_u64(32);
-    let __v_23: G = G::from_u64(183);
-    let __v_24: G = G::from_u64(126);
-    let __v_25: G = G::from_u64(222);
-    let __v_26: G = G::from_u64(195);
-    let __v_27: G = G::from_u64(56);
-    let __v_28: G = G::from_u64(186);
-    let __v_29: G = G::from_u64(60);
-    let __v_30: G = G::from_u64(251);
-    let __v_31: G = G::from_u64(200);
+    let __v_0: G = G::from_u64(222);
+    let __v_1: G = G::from_u64(11);
+    let __v_2: G = G::from_u64(239);
+    let __v_3: G = G::from_u64(168);
+    let __v_4: G = G::from_u64(79);
+    let __v_5: G = G::from_u64(170);
+    let __v_6: G = G::from_u64(34);
+    let __v_7: G = G::from_u64(209);
+    let __v_8: G = G::from_u64(57);
+    let __v_9: G = G::from_u64(67);
+    let __v_10: G = G::from_u64(121);
+    let __v_11: G = G::from_u64(160);
+    let __v_12: G = G::from_u64(186);
+    let __v_13: G = G::from_u64(103);
+    let __v_14: G = G::from_u64(41);
+    let __v_15: G = G::from_u64(110);
+    let __v_16: G = G::from_u64(17);
+    let __v_17: G = G::from_u64(102);
+    let __v_18: G = G::from_u64(96);
+    let __v_19: G = G::from_u64(247);
+    let __v_20: G = G::from_u64(129);
+    let __v_21: G = G::from_u64(180);
+    let __v_22: G = G::from_u64(235);
+    let __v_23: G = G::from_u64(99);
+    let __v_24: G = G::from_u64(157);
+    let __v_25: G = G::from_u64(187);
+    let __v_26: G = G::from_u64(171);
+    let __v_27: G = G::from_u64(162);
+    let __v_28: G = G::from_u64(0);
+    let __v_29: G = G::from_u64(239);
+    let __v_30: G = G::from_u64(43);
+    let __v_31: G = G::from_u64(248);
     let __v_32: G = { let __values: [G; 32] = [__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]; 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_261] = [__v_32];
-    record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_154] = [__v_32];
+    record.function_queries[154].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_262: usize = 0;
-const IN_262: usize = 0;
-const OUT_262: usize = 1;
-fn aiur_fn_262(
-  inp: [G; IN_262],
+const INPUT_SIZE_155: usize = 0;
+const IN_155: usize = 0;
+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_262], ExecError> {
+) -> Result<[G; OUT_155], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(28);
-    let __v_1: G = G::from_u64(23);
-    let __v_2: G = G::from_u64(0);
-    let __v_3: G = G::from_u64(152);
-    let __v_4: G = G::from_u64(226);
-    let __v_5: G = G::from_u64(49);
-    let __v_6: G = G::from_u64(67);
-    let __v_7: G = G::from_u64(253);
-    let __v_8: G = G::from_u64(143);
-    let __v_9: G = G::from_u64(214);
-    let __v_10: G = G::from_u64(23);
-    let __v_11: G = G::from_u64(44);
-    let __v_12: G = G::from_u64(239);
-    let __v_13: G = G::from_u64(210);
-    let __v_14: G = G::from_u64(236);
-    let __v_15: G = G::from_u64(238);
-    let __v_16: G = G::from_u64(48);
-    let __v_17: G = G::from_u64(80);
-    let __v_18: G = G::from_u64(114);
-    let __v_19: G = G::from_u64(210);
-    let __v_20: G = G::from_u64(153);
-    let __v_21: G = G::from_u64(17);
-    let __v_22: G = G::from_u64(19);
+    let __v_0: G = G::from_u64(162);
+    let __v_1: G = G::from_u64(154);
+    let __v_2: G = G::from_u64(99);
+    let __v_3: G = G::from_u64(97);
+    let __v_4: G = G::from_u64(118);
+    let __v_5: G = G::from_u64(207);
+    let __v_6: G = G::from_u64(17);
+    let __v_7: G = G::from_u64(53);
+    let __v_8: G = G::from_u64(208);
+    let __v_9: G = G::from_u64(119);
+    let __v_10: G = G::from_u64(235);
+    let __v_11: G = G::from_u64(7);
+    let __v_12: G = G::from_u64(71);
+    let __v_13: G = G::from_u64(152);
+    let __v_14: G = G::from_u64(249);
+    let __v_15: G = G::from_u64(0);
+    let __v_16: G = G::from_u64(124);
+    let __v_17: G = G::from_u64(120);
+    let __v_18: G = G::from_u64(231);
+    let __v_19: G = G::from_u64(128);
+    let __v_20: G = G::from_u64(19);
+    let __v_21: G = G::from_u64(131);
+    let __v_22: G = G::from_u64(233);
     let __v_23: G = G::from_u64(207);
-    let __v_24: G = G::from_u64(196);
-    let __v_25: G = G::from_u64(213);
-    let __v_26: G = G::from_u64(40);
-    let __v_27: G = G::from_u64(64);
-    let __v_28: G = G::from_u64(165);
-    let __v_29: G = G::from_u64(169);
-    let __v_30: G = G::from_u64(250);
-    let __v_31: G = G::from_u64(120);
+    let __v_24: G = G::from_u64(243);
+    let __v_25: G = G::from_u64(99);
+    let __v_26: G = G::from_u64(186);
+    let __v_27: G = G::from_u64(229);
+    let __v_28: G = G::from_u64(237);
+    let __v_29: G = G::from_u64(240);
+    let __v_30: G = G::from_u64(87);
+    let __v_31: G = G::from_u64(98);
     let __v_32: G = { let __values: [G; 32] = [__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]; 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_262] = [__v_32];
-    record.function_queries[262].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_155] = [__v_32];
+    record.function_queries[155].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_263: usize = 0;
-const IN_263: usize = 0;
-const OUT_263: usize = 1;
-fn aiur_fn_263(
-  inp: [G; IN_263],
+const INPUT_SIZE_156: usize = 0;
+const IN_156: usize = 0;
+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_263], ExecError> {
+) -> Result<[G; OUT_156], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(22);
-    let __v_1: G = G::from_u64(133);
-    let __v_2: G = G::from_u64(48);
-    let __v_3: G = G::from_u64(118);
-    let __v_4: G = G::from_u64(176);
-    let __v_5: G = G::from_u64(217);
-    let __v_6: G = G::from_u64(109);
-    let __v_7: G = G::from_u64(53);
-    let __v_8: G = G::from_u64(109);
-    let __v_9: G = G::from_u64(133);
-    let __v_10: G = G::from_u64(72);
-    let __v_11: G = G::from_u64(92);
-    let __v_12: G = G::from_u64(86);
-    let __v_13: G = G::from_u64(243);
-    let __v_14: G = G::from_u64(57);
-    let __v_15: G = G::from_u64(128);
-    let __v_16: G = G::from_u64(20);
-    let __v_17: G = G::from_u64(182);
-    let __v_18: G = G::from_u64(160);
-    let __v_19: G = G::from_u64(242);
-    let __v_20: G = G::from_u64(238);
-    let __v_21: G = G::from_u64(114);
-    let __v_22: G = G::from_u64(171);
-    let __v_23: G = G::from_u64(22);
-    let __v_24: G = G::from_u64(40);
-    let __v_25: G = G::from_u64(74);
-    let __v_26: G = G::from_u64(56);
-    let __v_27: G = G::from_u64(29);
-    let __v_28: G = G::from_u64(156);
-    let __v_29: G = G::from_u64(40);
-    let __v_30: G = G::from_u64(229);
-    let __v_31: G = G::from_u64(96);
+    let __v_0: G = G::from_u64(221);
+    let __v_1: G = G::from_u64(161);
+    let __v_2: G = G::from_u64(43);
+    let __v_3: G = G::from_u64(203);
+    let __v_4: G = G::from_u64(51);
+    let __v_5: G = G::from_u64(7);
+    let __v_6: G = G::from_u64(39);
+    let __v_7: G = G::from_u64(246);
+    let __v_8: G = G::from_u64(223);
+    let __v_9: G = G::from_u64(184);
+    let __v_10: G = G::from_u64(22);
+    let __v_11: G = G::from_u64(188);
+    let __v_12: G = G::from_u64(151);
+    let __v_13: G = G::from_u64(82);
+    let __v_14: G = G::from_u64(170);
+    let __v_15: G = G::from_u64(189);
+    let __v_16: G = G::from_u64(5);
+    let __v_17: G = G::from_u64(32);
+    let __v_18: G = G::from_u64(230);
+    let __v_19: G = G::from_u64(81);
+    let __v_20: G = G::from_u64(91);
+    let __v_21: G = G::from_u64(121);
+    let __v_22: G = G::from_u64(252);
+    let __v_23: G = G::from_u64(138);
+    let __v_24: G = G::from_u64(90);
+    let __v_25: G = G::from_u64(158);
+    let __v_26: G = G::from_u64(113);
+    let __v_27: G = G::from_u64(56);
+    let __v_28: G = G::from_u64(102);
+    let __v_29: G = G::from_u64(244);
+    let __v_30: G = G::from_u64(198);
+    let __v_31: G = G::from_u64(62);
     let __v_32: G = { let __values: [G; 32] = [__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]; 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_263] = [__v_32];
-    record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_156] = [__v_32];
+    record.function_queries[156].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_264: usize = 0;
-const IN_264: usize = 0;
-const OUT_264: usize = 1;
-fn aiur_fn_264(
-  inp: [G; IN_264],
+const INPUT_SIZE_157: usize = 0;
+const IN_157: usize = 0;
+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_264], ExecError> {
+) -> Result<[G; OUT_157], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(207);
     let __v_1: G = G::from_u64(134);
@@ -25979,70 +16184,168 @@ fn aiur_fn_264(
     let __v_30: G = G::from_u64(118);
     let __v_31: G = G::from_u64(216);
     let __v_32: G = { let __values: [G; 32] = [__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]; 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_264] = [__v_32];
-    record.function_queries[264].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_157] = [__v_32];
+    record.function_queries[157].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_158: usize = 0;
+const IN_158: usize = 0;
+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 = G::from_u64(123);
+    let __v_1: G = G::from_u64(216);
+    let __v_2: G = G::from_u64(225);
+    let __v_3: G = G::from_u64(159);
+    let __v_4: G = G::from_u64(71);
+    let __v_5: G = G::from_u64(246);
+    let __v_6: G = G::from_u64(234);
+    let __v_7: G = G::from_u64(230);
+    let __v_8: G = G::from_u64(32);
+    let __v_9: G = G::from_u64(165);
+    let __v_10: G = G::from_u64(195);
+    let __v_11: G = G::from_u64(159);
+    let __v_12: G = G::from_u64(36);
+    let __v_13: G = G::from_u64(60);
+    let __v_14: G = G::from_u64(228);
+    let __v_15: G = G::from_u64(21);
+    let __v_16: G = G::from_u64(221);
+    let __v_17: G = G::from_u64(106);
+    let __v_18: G = G::from_u64(119);
+    let __v_19: G = G::from_u64(240);
+    let __v_20: G = G::from_u64(149);
+    let __v_21: G = G::from_u64(144);
+    let __v_22: G = G::from_u64(244);
+    let __v_23: G = G::from_u64(194);
+    let __v_24: G = G::from_u64(39);
+    let __v_25: G = G::from_u64(206);
+    let __v_26: G = G::from_u64(243);
+    let __v_27: G = G::from_u64(99);
+    let __v_28: G = G::from_u64(0);
+    let __v_29: G = G::from_u64(127);
+    let __v_30: G = G::from_u64(64);
+    let __v_31: G = G::from_u64(18);
+    let __v_32: G = { let __values: [G; 32] = [__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]; 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_158] = [__v_32];
+    record.function_queries[158].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_159: usize = 0;
+const IN_159: usize = 0;
+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 = G::from_u64(28);
+    let __v_1: G = G::from_u64(23);
+    let __v_2: G = G::from_u64(0);
+    let __v_3: G = G::from_u64(152);
+    let __v_4: G = G::from_u64(226);
+    let __v_5: G = G::from_u64(49);
+    let __v_6: G = G::from_u64(67);
+    let __v_7: G = G::from_u64(253);
+    let __v_8: G = G::from_u64(143);
+    let __v_9: G = G::from_u64(214);
+    let __v_10: G = G::from_u64(23);
+    let __v_11: G = G::from_u64(44);
+    let __v_12: G = G::from_u64(239);
+    let __v_13: G = G::from_u64(210);
+    let __v_14: G = G::from_u64(236);
+    let __v_15: G = G::from_u64(238);
+    let __v_16: G = G::from_u64(48);
+    let __v_17: G = G::from_u64(80);
+    let __v_18: G = G::from_u64(114);
+    let __v_19: G = G::from_u64(210);
+    let __v_20: G = G::from_u64(153);
+    let __v_21: G = G::from_u64(17);
+    let __v_22: G = G::from_u64(19);
+    let __v_23: G = G::from_u64(207);
+    let __v_24: G = G::from_u64(196);
+    let __v_25: G = G::from_u64(213);
+    let __v_26: G = G::from_u64(40);
+    let __v_27: G = G::from_u64(64);
+    let __v_28: G = G::from_u64(165);
+    let __v_29: G = G::from_u64(169);
+    let __v_30: G = G::from_u64(250);
+    let __v_31: G = G::from_u64(120);
+    let __v_32: G = { let __values: [G; 32] = [__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]; 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_159] = [__v_32];
+    record.function_queries[159].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_265: usize = 0;
-const IN_265: usize = 0;
-const OUT_265: usize = 1;
-fn aiur_fn_265(
-  inp: [G; IN_265],
+const INPUT_SIZE_160: usize = 0;
+const IN_160: usize = 0;
+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_265], ExecError> {
+) -> Result<[G; OUT_160], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(245);
-    let __v_1: G = G::from_u64(210);
-    let __v_2: G = G::from_u64(86);
-    let __v_3: G = G::from_u64(193);
-    let __v_4: G = G::from_u64(221);
-    let __v_5: G = G::from_u64(121);
-    let __v_6: G = G::from_u64(77);
-    let __v_7: G = G::from_u64(2);
-    let __v_8: G = G::from_u64(207);
-    let __v_9: G = G::from_u64(223);
-    let __v_10: G = G::from_u64(23);
-    let __v_11: G = G::from_u64(98);
-    let __v_12: G = G::from_u64(201);
-    let __v_13: G = G::from_u64(228);
-    let __v_14: G = G::from_u64(27);
-    let __v_15: G = G::from_u64(19);
-    let __v_16: G = G::from_u64(171);
-    let __v_17: G = G::from_u64(229);
-    let __v_18: G = G::from_u64(189);
-    let __v_19: G = G::from_u64(221);
-    let __v_20: G = G::from_u64(225);
-    let __v_21: G = G::from_u64(45);
-    let __v_22: G = G::from_u64(146);
-    let __v_23: G = G::from_u64(157);
-    let __v_24: G = G::from_u64(2);
-    let __v_25: G = G::from_u64(173);
-    let __v_26: G = G::from_u64(163);
-    let __v_27: G = G::from_u64(126);
-    let __v_28: G = G::from_u64(79);
-    let __v_29: G = G::from_u64(64);
-    let __v_30: G = G::from_u64(232);
-    let __v_31: G = G::from_u64(95);
+    let __v_0: G = G::from_u64(22);
+    let __v_1: G = G::from_u64(133);
+    let __v_2: G = G::from_u64(48);
+    let __v_3: G = G::from_u64(118);
+    let __v_4: G = G::from_u64(176);
+    let __v_5: G = G::from_u64(217);
+    let __v_6: G = G::from_u64(109);
+    let __v_7: G = G::from_u64(53);
+    let __v_8: G = G::from_u64(109);
+    let __v_9: G = G::from_u64(133);
+    let __v_10: G = G::from_u64(72);
+    let __v_11: G = G::from_u64(92);
+    let __v_12: G = G::from_u64(86);
+    let __v_13: G = G::from_u64(243);
+    let __v_14: G = G::from_u64(57);
+    let __v_15: G = G::from_u64(128);
+    let __v_16: G = G::from_u64(20);
+    let __v_17: G = G::from_u64(182);
+    let __v_18: G = G::from_u64(160);
+    let __v_19: G = G::from_u64(242);
+    let __v_20: G = G::from_u64(238);
+    let __v_21: G = G::from_u64(114);
+    let __v_22: G = G::from_u64(171);
+    let __v_23: G = G::from_u64(22);
+    let __v_24: G = G::from_u64(40);
+    let __v_25: G = G::from_u64(74);
+    let __v_26: G = G::from_u64(56);
+    let __v_27: G = G::from_u64(29);
+    let __v_28: G = G::from_u64(156);
+    let __v_29: G = G::from_u64(40);
+    let __v_30: G = G::from_u64(229);
+    let __v_31: G = G::from_u64(96);
     let __v_32: G = { let __values: [G; 32] = [__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]; 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_265] = [__v_32];
-    record.function_queries[265].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_160] = [__v_32];
+    record.function_queries[160].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_266: usize = 0;
-const IN_266: usize = 0;
-const OUT_266: usize = 1;
-fn aiur_fn_266(
-  inp: [G; IN_266],
+const INPUT_SIZE_161: usize = 0;
+const IN_161: usize = 0;
+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_266], ExecError> {
+) -> Result<[G; OUT_161], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(11);
     let __v_1: G = G::from_u64(89);
@@ -26077,70 +16380,70 @@ fn aiur_fn_266(
     let __v_30: G = G::from_u64(96);
     let __v_31: G = G::from_u64(146);
     let __v_32: G = { let __values: [G; 32] = [__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]; 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_266] = [__v_32];
-    record.function_queries[266].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_161] = [__v_32];
+    record.function_queries[161].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_267: usize = 0;
-const IN_267: usize = 0;
-const OUT_267: usize = 1;
-fn aiur_fn_267(
-  inp: [G; IN_267],
+const INPUT_SIZE_162: usize = 0;
+const IN_162: usize = 0;
+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_267], ExecError> {
+) -> Result<[G; OUT_162], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(123);
-    let __v_1: G = G::from_u64(216);
-    let __v_2: G = G::from_u64(225);
-    let __v_3: G = G::from_u64(159);
-    let __v_4: G = G::from_u64(71);
-    let __v_5: G = G::from_u64(246);
-    let __v_6: G = G::from_u64(234);
-    let __v_7: G = G::from_u64(230);
-    let __v_8: G = G::from_u64(32);
-    let __v_9: G = G::from_u64(165);
-    let __v_10: G = G::from_u64(195);
-    let __v_11: G = G::from_u64(159);
-    let __v_12: G = G::from_u64(36);
-    let __v_13: G = G::from_u64(60);
-    let __v_14: G = G::from_u64(228);
-    let __v_15: G = G::from_u64(21);
-    let __v_16: G = G::from_u64(221);
-    let __v_17: G = G::from_u64(106);
-    let __v_18: G = G::from_u64(119);
-    let __v_19: G = G::from_u64(240);
-    let __v_20: G = G::from_u64(149);
-    let __v_21: G = G::from_u64(144);
-    let __v_22: G = G::from_u64(244);
-    let __v_23: G = G::from_u64(194);
-    let __v_24: G = G::from_u64(39);
-    let __v_25: G = G::from_u64(206);
-    let __v_26: G = G::from_u64(243);
-    let __v_27: G = G::from_u64(99);
-    let __v_28: G = G::from_u64(0);
-    let __v_29: G = G::from_u64(127);
-    let __v_30: G = G::from_u64(64);
-    let __v_31: G = G::from_u64(18);
+    let __v_0: G = G::from_u64(245);
+    let __v_1: G = G::from_u64(210);
+    let __v_2: G = G::from_u64(86);
+    let __v_3: G = G::from_u64(193);
+    let __v_4: G = G::from_u64(221);
+    let __v_5: G = G::from_u64(121);
+    let __v_6: G = G::from_u64(77);
+    let __v_7: G = G::from_u64(2);
+    let __v_8: G = G::from_u64(207);
+    let __v_9: G = G::from_u64(223);
+    let __v_10: G = G::from_u64(23);
+    let __v_11: G = G::from_u64(98);
+    let __v_12: G = G::from_u64(201);
+    let __v_13: G = G::from_u64(228);
+    let __v_14: G = G::from_u64(27);
+    let __v_15: G = G::from_u64(19);
+    let __v_16: G = G::from_u64(171);
+    let __v_17: G = G::from_u64(229);
+    let __v_18: G = G::from_u64(189);
+    let __v_19: G = G::from_u64(221);
+    let __v_20: G = G::from_u64(225);
+    let __v_21: G = G::from_u64(45);
+    let __v_22: G = G::from_u64(146);
+    let __v_23: G = G::from_u64(157);
+    let __v_24: G = G::from_u64(2);
+    let __v_25: G = G::from_u64(173);
+    let __v_26: G = G::from_u64(163);
+    let __v_27: G = G::from_u64(126);
+    let __v_28: G = G::from_u64(79);
+    let __v_29: G = G::from_u64(64);
+    let __v_30: G = G::from_u64(232);
+    let __v_31: G = G::from_u64(95);
     let __v_32: G = { let __values: [G; 32] = [__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]; 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_267] = [__v_32];
-    record.function_queries[267].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_162] = [__v_32];
+    record.function_queries[162].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_268: usize = 0;
-const IN_268: usize = 0;
-const OUT_268: usize = 1;
-fn aiur_fn_268(
-  inp: [G; IN_268],
+const INPUT_SIZE_163: usize = 0;
+const IN_163: usize = 0;
+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_268], ExecError> {
+) -> Result<[G; OUT_163], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(56);
     let __v_1: G = G::from_u64(151);
@@ -26175,21 +16478,21 @@ fn aiur_fn_268(
     let __v_30: G = G::from_u64(25);
     let __v_31: G = G::from_u64(205);
     let __v_32: G = { let __values: [G; 32] = [__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]; 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_268] = [__v_32];
-    record.function_queries[268].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_163] = [__v_32];
+    record.function_queries[163].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_269: usize = 0;
-const IN_269: usize = 0;
-const OUT_269: usize = 1;
-fn aiur_fn_269(
-  inp: [G; IN_269],
+const INPUT_SIZE_164: usize = 0;
+const IN_164: usize = 0;
+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_269], ExecError> {
+) -> Result<[G; OUT_164], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(45);
     let __v_1: G = G::from_u64(252);
@@ -26224,21 +16527,21 @@ fn aiur_fn_269(
     let __v_30: G = G::from_u64(105);
     let __v_31: G = G::from_u64(91);
     let __v_32: G = { let __values: [G; 32] = [__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]; 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_269] = [__v_32];
-    record.function_queries[269].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_164] = [__v_32];
+    record.function_queries[164].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_270: usize = 0;
-const IN_270: usize = 0;
-const OUT_270: usize = 1;
-fn aiur_fn_270(
-  inp: [G; IN_270],
+const INPUT_SIZE_165: usize = 0;
+const IN_165: usize = 0;
+const OUT_165: usize = 1;
+fn aiur_fn_165(
+  inp: [G; IN_165],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_270], ExecError> {
+) -> Result<[G; OUT_165], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(146);
     let __v_1: G = G::from_u64(50);
@@ -26273,952 +16576,1700 @@ fn aiur_fn_270(
     let __v_30: G = G::from_u64(15);
     let __v_31: G = G::from_u64(235);
     let __v_32: G = { let __values: [G; 32] = [__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]; 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_270] = [__v_32];
-    record.function_queries[270].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_165] = [__v_32];
+    record.function_queries[165].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_271: usize = 0;
-const IN_271: usize = 0;
-const OUT_271: usize = 1;
-fn aiur_fn_271(
-  inp: [G; IN_271],
+const INPUT_SIZE_166: usize = 1;
+const IN_166: usize = 1;
+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_271], ExecError> {
+) -> Result<[G; OUT_166], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(57);
-    let __v_1: G = G::from_u64(138);
-    let __v_2: G = G::from_u64(119);
-    let __v_3: G = G::from_u64(6);
-    let __v_4: G = G::from_u64(207);
-    let __v_5: G = G::from_u64(19);
-    let __v_6: G = G::from_u64(242);
-    let __v_7: G = G::from_u64(35);
-    let __v_8: G = G::from_u64(153);
-    let __v_9: G = G::from_u64(45);
-    let __v_10: G = G::from_u64(23);
-    let __v_11: G = G::from_u64(61);
-    let __v_12: G = G::from_u64(206);
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[157].get_mut(&__args[..]) { 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_1: G = __r_arr[0];
+    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_2: G = __r_arr[0];
+    match __v_2.as_canonical_u64() {
+      1u64 => {
+        let __v_3: G = G::from_u64(1);
+        let __ret: [G; OUT_166] = [__v_3];
+        record.function_queries[166].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { 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_3: G = __r_arr[0];
+        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_4: G = __r_arr[0];
+        match __v_4.as_canonical_u64() {
+          1u64 => {
+            let __v_5: G = G::from_u64(1);
+            let __ret: [G; OUT_166] = [__v_5];
+            record.function_queries[166].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { 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_5: G = __r_arr[0];
+            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_6: G = __r_arr[0];
+            match __v_6.as_canonical_u64() {
+              1u64 => {
+                let __v_7: G = G::from_u64(1);
+                let __ret: [G; OUT_166] = [__v_7];
+                record.function_queries[166].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[160].get_mut(&__args[..]) { 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_7: G = __r_arr[0];
+                let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_8: G = __r_arr[0];
+                match __v_8.as_canonical_u64() {
+                  1u64 => {
+                    let __v_9: G = G::from_u64(1);
+                    let __ret: [G; OUT_166] = [__v_9];
+                    record.function_queries[166].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
+                  },
+                  _ => {
+                    let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { 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_9: G = __r_arr[0];
+                    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_10: G = __r_arr[0];
+                    match __v_10.as_canonical_u64() {
+                      1u64 => {
+                        let __v_11: G = G::from_u64(1);
+                        let __ret: [G; OUT_166] = [__v_11];
+                        record.function_queries[166].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        return Ok(__ret);
+                      },
+                      _ => {
+                        let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[163].get_mut(&__args[..]) { 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_11: G = __r_arr[0];
+                        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_12: G = __r_arr[0];
+                        match __v_12.as_canonical_u64() {
+                          1u64 => {
+                            let __v_13: G = G::from_u64(1);
+                            let __ret: [G; OUT_166] = [__v_13];
+                            record.function_queries[166].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            return Ok(__ret);
+                          },
+                          _ => {
+                            let __v_13: G = G::from_u64(0);
+                            let __ret: [G; OUT_166] = [__v_13];
+                            record.function_queries[166].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            return Ok(__ret);
+                          },
+                        }
+                      },
+                    }
+                  },
+                }
+              },
+            }
+          },
+        }
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_167: usize = 0;
+const IN_167: usize = 0;
+const OUT_167: usize = 1;
+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 = G::from_u64(0);
+    let __v_1: G = G::from_u64(64);
+    let __v_2: G = G::from_u64(0);
+    let __v_3: G = G::from_u64(0);
+    let __v_4: G = G::from_u64(0);
+    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(1);
+    let __v_10: G = G::from_u64(1);
+    let __v_11: G = { let __values: [G; 10] = [__v_9, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10]; 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_12: G = { let __values: [G; 10] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_11]; 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_13: G = G::from_u64(7);
-    let __v_14: G = G::from_u64(148);
-    let __v_15: G = G::from_u64(104);
-    let __v_16: G = G::from_u64(87);
-    let __v_17: G = G::from_u64(36);
-    let __v_18: G = G::from_u64(15);
-    let __v_19: G = G::from_u64(73);
-    let __v_20: G = G::from_u64(175);
-    let __v_21: G = G::from_u64(204);
-    let __v_22: G = G::from_u64(116);
-    let __v_23: G = G::from_u64(55);
-    let __v_24: G = G::from_u64(35);
-    let __v_25: G = G::from_u64(232);
-    let __v_26: G = G::from_u64(57);
-    let __v_27: G = G::from_u64(248);
-    let __v_28: G = G::from_u64(243);
-    let __v_29: G = G::from_u64(242);
-    let __v_30: G = G::from_u64(182);
-    let __v_31: G = G::from_u64(49);
-    let __v_32: G = { let __values: [G; 32] = [__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]; 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_271] = [__v_32];
-    record.function_queries[271].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __v_14: G = G::from_u64(0);
+    let __v_15: G = G::from_u64(0);
+    let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_12, __v_15]; 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_167] = [__v_16];
+    record.function_queries[167].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_272: usize = 0;
-const IN_272: usize = 0;
-const OUT_272: usize = 1;
-fn aiur_fn_272(
-  inp: [G; IN_272],
+const INPUT_SIZE_168: usize = 0;
+const IN_168: usize = 0;
+const OUT_168: usize = 1;
+fn aiur_fn_168(
+  inp: [G; IN_168],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_272], ExecError> {
+) -> Result<[G; OUT_168], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = G::from_u64(0);
+    let __v_1: G = G::from_u64(1);
+    let __v_2: G = G::from_u64(0);
+    let __v_3: G = G::from_u64(0);
+    let __v_4: G = G::from_u64(0);
+    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(1);
+    let __v_10: G = G::from_u64(1);
+    let __v_11: G = { let __values: [G; 10] = [__v_9, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10]; 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_12: G = { let __values: [G; 10] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_11]; 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_13: G = G::from_u64(7);
+    let __v_14: G = G::from_u64(0);
+    let __v_15: G = G::from_u64(0);
+    let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_12, __v_15]; 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_168] = [__v_16];
+    record.function_queries[168].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_169: usize = 3;
+const IN_169: usize = 3;
+const OUT_169: usize = 2;
+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 __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[157].get_mut(&__args[..]) { 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_3: G = __r_arr[0];
+    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_4: G = __r_arr[0];
+    match __v_4.as_canonical_u64() {
+      1u64 => {
+        let __v_5: G = G::from_u64(1);
+        let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[167].get_mut(&__args[..]) { 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_6: G = __r_arr[0];
+        let __ret: [G; OUT_169] = [__v_5, __v_6];
+        record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { 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_5: G = __r_arr[0];
+        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_6: G = __r_arr[0];
+        match __v_6.as_canonical_u64() {
+          1u64 => {
+            let __v_7: G = G::from_u64(1);
+            let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[168].get_mut(&__args[..]) { 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_8: G = __r_arr[0];
+            let __ret: [G; OUT_169] = [__v_7, __v_8];
+            record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { 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_7: G = __r_arr[0];
+            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_8: G = __r_arr[0];
+            match __v_8.as_canonical_u64() {
+              1u64 => {
+                let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { 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_9: G = __r_arr[0];
+                let __v_10: G = __r_arr[1];
+                let __ret: [G; OUT_169] = [__v_9, __v_10];
+                record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[163].get_mut(&__args[..]) { 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_9: G = __r_arr[0];
+                let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_10: G = __r_arr[0];
+                match __v_10.as_canonical_u64() {
+                  1u64 => {
+                    let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[171].get_mut(&__args[..]) { 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 __v_11: G = __r_arr[0];
+                    let __v_12: G = __r_arr[1];
+                    let __ret: [G; OUT_169] = [__v_11, __v_12];
+                    record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
+                  },
+                  _ => {
+                    let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { 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_11: G = __r_arr[0];
+                    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_12: G = __r_arr[0];
+                    let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[160].get_mut(&__args[..]) { 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_13: G = __r_arr[0];
+                    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_14: G = __r_arr[0];
+                    let __v_15: G = (__v_12 + __v_14);
+                    match __v_15.as_canonical_u64() {
+                      0u64 => {
+                        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 = { let __values: [G; 4] = [__v_17, __v_18, __v_19, __v_19]; 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_16, __v_20];
+                        record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        return Ok(__ret);
+                      },
+                      _ => {
+                        let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } else { aiur_fn_711(__args, record, io_buffer, __cu)? } };
+                        let __v_16: G = __r_arr[0];
+                        let __v_17: G = G::from_u64(1);
+                        let __v_18: G = { let __a_val = __v_16.as_canonical_u64(); let __b_val = __v_17.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_18.as_canonical_u64() {
+                          1u64 => {
+                            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 = { let __values: [G; 4] = [__v_20, __v_21, __v_22, __v_22]; 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_19, __v_23];
+                            record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            return Ok(__ret);
+                          },
+                          _ => {
+                            let __v_19: G = G::from_u64(0);
+                            let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_1, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } };
+                            let __v_20: G = __r_arr[0];
+                            let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_20, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = unsafe { *(result.output.as_ptr() as *const [G; OUT_377]) }; __ret } else { aiur_fn_377(__args, record, io_buffer, __cu)? } };
+                            let __v_21: G = __r_arr[0];
+                            match __v_12.as_canonical_u64() {
+                              1u64 => {
+                                let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[172].get_mut(&__args[..]) { 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 __v_22: G = __r_arr[0];
+                                let __v_23: G = __r_arr[1];
+                                let __ret: [G; OUT_169] = [__v_22, __v_23];
+                                record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                return Ok(__ret);
+                              },
+                              _ => {
+                                let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[173].get_mut(&__args[..]) { 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_22: G = __r_arr[0];
+                                let __v_23: G = __r_arr[1];
+                                let __ret: [G; OUT_169] = [__v_22, __v_23];
+                                record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                return Ok(__ret);
+                              },
+                            }
+                          },
+                        }
+                      },
+                    }
+                  },
+                }
+              },
+            }
+          },
+        }
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_170: usize = 1;
+const IN_170: usize = 1;
+const OUT_170: usize = 2;
+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 __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } else { aiur_fn_711(__args, record, io_buffer, __cu)? } };
+    let __v_1: G = __r_arr[0];
+    let __v_2: G = G::from_u64(3);
+    let __v_3: G = { let __a_val = __v_1.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_3.as_canonical_u64() {
+      1u64 => {
+        let __v_4: G = G::from_u64(0);
+        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 = { let __values: [G; 4] = [__v_5, __v_6, __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_170] = [__v_4, __v_8];
+        record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __v_4: G = G::from_u64(2);
+        let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } };
+        let __v_5: G = __r_arr[0];
+        let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[106].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_106] = unsafe { *(result.output.as_ptr() as *const [G; OUT_106]) }; __ret } else { aiur_fn_106(__args, record, io_buffer, __cu)? } };
+        let __v_6: G = __r_arr[0];
+        let __v_7: G = __r_arr[1];
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; 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: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].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];
+        match __v_8.as_canonical_u64() {
+          2u64 => {
+            let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { 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_12: G = __r_arr[0];
+            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_9, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_13: G = __r_arr[0];
+            match __v_13.as_canonical_u64() {
+              1u64 => {
+                let __v_14: G = G::from_u64(1);
+                let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[167].get_mut(&__args[..]) { 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_15: G = __r_arr[0];
+                let __ret: [G; OUT_170] = [__v_14, __v_15];
+                record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                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 = G::from_u64(0);
+                let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; 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_170] = [__v_14, __v_18];
+                record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+            }
+          },
+          _ => {
+            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 = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; 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_170] = [__v_12, __v_16];
+            record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+        }
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_171: usize = 1;
+const IN_171: usize = 1;
+const OUT_171: usize = 2;
+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 = G::from_u64(211);
-    let __v_1: G = G::from_u64(151);
-    let __v_2: G = G::from_u64(55);
-    let __v_3: G = G::from_u64(1);
-    let __v_4: G = G::from_u64(87);
-    let __v_5: G = G::from_u64(251);
-    let __v_6: G = G::from_u64(154);
-    let __v_7: G = G::from_u64(226);
-    let __v_8: G = G::from_u64(198);
-    let __v_9: G = G::from_u64(225);
-    let __v_10: G = G::from_u64(237);
-    let __v_11: G = G::from_u64(167);
-    let __v_12: G = G::from_u64(159);
-    let __v_13: G = G::from_u64(235);
-    let __v_14: G = G::from_u64(16);
-    let __v_15: G = G::from_u64(191);
-    let __v_16: G = G::from_u64(73);
-    let __v_17: G = G::from_u64(116);
-    let __v_18: G = G::from_u64(1);
-    let __v_19: G = G::from_u64(116);
-    let __v_20: G = G::from_u64(26);
-    let __v_21: G = G::from_u64(186);
-    let __v_22: G = G::from_u64(120);
-    let __v_23: G = G::from_u64(143);
-    let __v_24: G = G::from_u64(171);
-    let __v_25: G = G::from_u64(114);
-    let __v_26: G = G::from_u64(108);
-    let __v_27: G = G::from_u64(250);
-    let __v_28: G = G::from_u64(76);
-    let __v_29: G = G::from_u64(70);
-    let __v_30: G = G::from_u64(125);
-    let __v_31: G = G::from_u64(182);
-    let __v_32: G = { let __values: [G; 32] = [__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]; 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_272] = [__v_32];
-    record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } else { aiur_fn_711(__args, record, io_buffer, __cu)? } };
+    let __v_1: G = __r_arr[0];
+    let __v_2: G = G::from_u64(1);
+    let __v_3: G = { let __a_val = __v_1.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_3.as_canonical_u64() {
+      1u64 => {
+        let __v_4: G = G::from_u64(0);
+        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 = { let __values: [G; 4] = [__v_5, __v_6, __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_171] = [__v_4, __v_8];
+        record.function_queries[171].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __v_4: G = G::from_u64(0);
+        let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } };
+        let __v_5: G = __r_arr[0];
+        let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[106].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_106] = unsafe { *(result.output.as_ptr() as *const [G; OUT_106]) }; __ret } else { aiur_fn_106(__args, record, io_buffer, __cu)? } };
+        let __v_6: G = __r_arr[0];
+        let __v_7: G = __r_arr[1];
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; 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: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].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];
+        match __v_8.as_canonical_u64() {
+          2u64 => {
+            let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[165].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_165] = unsafe { *(result.output.as_ptr() as *const [G; OUT_165]) }; __ret } else { aiur_fn_165(__args, record, io_buffer, __cu)? } };
+            let __v_12: G = __r_arr[0];
+            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_9, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_13: G = __r_arr[0];
+            match __v_13.as_canonical_u64() {
+              1u64 => {
+                let __v_14: G = G::from_u64(1);
+                let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[168].get_mut(&__args[..]) { 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_15: G = __r_arr[0];
+                let __ret: [G; OUT_171] = [__v_14, __v_15];
+                record.function_queries[171].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_9, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_15: G = __r_arr[0];
+                match __v_15.as_canonical_u64() {
+                  1u64 => {
+                    let __v_16: G = G::from_u64(1);
+                    let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[168].get_mut(&__args[..]) { 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_17: G = __r_arr[0];
+                    let __ret: [G; OUT_171] = [__v_16, __v_17];
+                    record.function_queries[171].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
+                  },
+                  _ => {
+                    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 = { let __values: [G; 4] = [__v_17, __v_18, __v_19, __v_19]; 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_171] = [__v_16, __v_20];
+                    record.function_queries[171].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
+                  },
+                }
+              },
+            }
+          },
+          _ => {
+            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 = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; 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_171] = [__v_12, __v_16];
+            record.function_queries[171].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+        }
+      },
+    }
   })
 }
 
-const INPUT_SIZE_273: usize = 0;
-const IN_273: usize = 0;
-const OUT_273: usize = 1;
-fn aiur_fn_273(
-  inp: [G; IN_273],
+const INPUT_SIZE_172: usize = 1;
+const IN_172: usize = 1;
+const OUT_172: usize = 2;
+fn aiur_fn_172(
+  inp: [G; IN_172],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_273], ExecError> {
+) -> Result<[G; OUT_172], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(222);
-    let __v_1: G = G::from_u64(245);
-    let __v_2: G = G::from_u64(45);
-    let __v_3: G = G::from_u64(29);
-    let __v_4: G = G::from_u64(173);
-    let __v_5: G = G::from_u64(95);
-    let __v_6: G = G::from_u64(16);
-    let __v_7: G = G::from_u64(207);
-    let __v_8: G = G::from_u64(152);
-    let __v_9: G = G::from_u64(147);
-    let __v_10: G = G::from_u64(201);
-    let __v_11: G = G::from_u64(69);
-    let __v_12: G = G::from_u64(225);
-    let __v_13: G = G::from_u64(105);
-    let __v_14: G = G::from_u64(113);
-    let __v_15: G = G::from_u64(141);
-    let __v_16: G = G::from_u64(98);
-    let __v_17: G = G::from_u64(177);
-    let __v_18: G = G::from_u64(94);
-    let __v_19: G = G::from_u64(45);
-    let __v_20: G = G::from_u64(210);
-    let __v_21: G = G::from_u64(201);
-    let __v_22: G = G::from_u64(6);
-    let __v_23: G = G::from_u64(110);
-    let __v_24: G = G::from_u64(89);
-    let __v_25: G = G::from_u64(123);
-    let __v_26: G = G::from_u64(157);
-    let __v_27: G = G::from_u64(69);
-    let __v_28: G = G::from_u64(112);
-    let __v_29: G = G::from_u64(186);
-    let __v_30: G = G::from_u64(5);
-    let __v_31: G = G::from_u64(110);
-    let __v_32: G = { let __values: [G; 32] = [__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]; 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_273] = [__v_32];
-    record.function_queries[273].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
+    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() {
+      2u64 => {
+        let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[155].get_mut(&__args[..]) { 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_5: G = __r_arr[0];
+        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_6: G = __r_arr[0];
+        let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { 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_7: G = __r_arr[0];
+        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_8: G = __r_arr[0];
+        let __v_9: G = (__v_6 + __v_8);
+        match __v_9.as_canonical_u64() {
+          0u64 => {
+            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 = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; 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_172] = [__v_10, __v_14];
+            record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            let __v_10: G = G::from_u64(1);
+            let __ret: [G; OUT_172] = [__v_10, __v_0];
+            record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+        }
+      },
+      _ => {
+        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; 4] = [__v_6, __v_7, __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_172] = [__v_5, __v_9];
+        record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+    }
   })
 }
 
-const INPUT_SIZE_274: usize = 0;
-const IN_274: usize = 0;
-const OUT_274: usize = 1;
-fn aiur_fn_274(
-  inp: [G; IN_274],
+const INPUT_SIZE_173: usize = 1;
+const IN_173: usize = 1;
+const OUT_173: usize = 2;
+fn aiur_fn_173(
+  inp: [G; IN_173],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_274], ExecError> {
+) -> Result<[G; OUT_173], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(145);
-    let __v_1: G = G::from_u64(79);
-    let __v_2: G = G::from_u64(156);
-    let __v_3: G = G::from_u64(1);
-    let __v_4: G = G::from_u64(136);
-    let __v_5: G = G::from_u64(72);
-    let __v_6: G = G::from_u64(83);
-    let __v_7: G = G::from_u64(101);
-    let __v_8: G = G::from_u64(46);
-    let __v_9: G = G::from_u64(146);
-    let __v_10: G = G::from_u64(36);
-    let __v_11: G = G::from_u64(220);
-    let __v_12: G = G::from_u64(81);
-    let __v_13: G = G::from_u64(31);
-    let __v_14: G = G::from_u64(134);
-    let __v_15: G = G::from_u64(125);
-    let __v_16: G = G::from_u64(84);
-    let __v_17: G = G::from_u64(8);
-    let __v_18: G = G::from_u64(81);
-    let __v_19: G = G::from_u64(127);
-    let __v_20: G = G::from_u64(59);
-    let __v_21: G = G::from_u64(235);
-    let __v_22: G = G::from_u64(49);
-    let __v_23: G = G::from_u64(146);
-    let __v_24: G = G::from_u64(252);
-    let __v_25: G = G::from_u64(68);
-    let __v_26: G = G::from_u64(119);
-    let __v_27: G = G::from_u64(224);
-    let __v_28: G = G::from_u64(233);
-    let __v_29: G = G::from_u64(89);
-    let __v_30: G = G::from_u64(76);
-    let __v_31: G = G::from_u64(136);
-    let __v_32: G = { let __values: [G; 32] = [__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]; 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_274] = [__v_32];
-    record.function_queries[274].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
+    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() {
+      7u64 => {
+        match __v_2.as_canonical_u64() {
+          0u64 => {
+            let __v_5: G = G::from_u64(1);
+            let __ret: [G; OUT_173] = [__v_5, __v_0];
+            record.function_queries[173].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            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; 4] = [__v_6, __v_7, __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_173] = [__v_5, __v_9];
+            record.function_queries[173].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+        }
+      },
+      _ => {
+        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; 4] = [__v_6, __v_7, __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_173] = [__v_5, __v_9];
+        record.function_queries[173].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+    }
   })
 }
 
-const INPUT_SIZE_275: usize = 0;
-const IN_275: usize = 0;
-const OUT_275: usize = 1;
-fn aiur_fn_275(
-  inp: [G; IN_275],
+const INPUT_SIZE_174: usize = 0;
+const IN_174: usize = 0;
+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_275], ExecError> {
+) -> Result<[G; OUT_174], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(214);
-    let __v_1: G = G::from_u64(246);
-    let __v_2: G = G::from_u64(42);
-    let __v_3: G = G::from_u64(151);
-    let __v_4: G = G::from_u64(121);
-    let __v_5: G = G::from_u64(16);
-    let __v_6: G = G::from_u64(143);
-    let __v_7: G = G::from_u64(159);
-    let __v_8: G = G::from_u64(182);
-    let __v_9: G = G::from_u64(182);
-    let __v_10: G = G::from_u64(107);
-    let __v_11: G = G::from_u64(49);
-    let __v_12: G = G::from_u64(204);
-    let __v_13: G = G::from_u64(148);
-    let __v_14: G = G::from_u64(195);
-    let __v_15: G = G::from_u64(216);
-    let __v_16: G = G::from_u64(76);
-    let __v_17: G = G::from_u64(167);
-    let __v_18: G = G::from_u64(45);
-    let __v_19: G = G::from_u64(139);
-    let __v_20: G = G::from_u64(234);
-    let __v_21: G = G::from_u64(24);
-    let __v_22: G = G::from_u64(94);
-    let __v_23: G = G::from_u64(19);
-    let __v_24: G = G::from_u64(19);
-    let __v_25: G = G::from_u64(124);
-    let __v_26: G = G::from_u64(80);
-    let __v_27: G = G::from_u64(199);
-    let __v_28: G = G::from_u64(239);
-    let __v_29: G = G::from_u64(132);
-    let __v_30: G = G::from_u64(201);
-    let __v_31: G = G::from_u64(105);
+    let __v_0: G = G::from_u64(119);
+    let __v_1: G = G::from_u64(160);
+    let __v_2: G = G::from_u64(37);
+    let __v_3: G = G::from_u64(193);
+    let __v_4: G = G::from_u64(159);
+    let __v_5: G = G::from_u64(139);
+    let __v_6: G = G::from_u64(225);
+    let __v_7: G = G::from_u64(49);
+    let __v_8: G = G::from_u64(251);
+    let __v_9: G = G::from_u64(157);
+    let __v_10: G = G::from_u64(91);
+    let __v_11: G = G::from_u64(11);
+    let __v_12: G = G::from_u64(236);
+    let __v_13: G = G::from_u64(73);
+    let __v_14: G = G::from_u64(72);
+    let __v_15: G = G::from_u64(23);
+    let __v_16: G = G::from_u64(162);
+    let __v_17: G = G::from_u64(101);
+    let __v_18: G = G::from_u64(56);
+    let __v_19: G = G::from_u64(185);
+    let __v_20: G = G::from_u64(165);
+    let __v_21: G = G::from_u64(80);
+    let __v_22: G = G::from_u64(171);
+    let __v_23: G = G::from_u64(187);
+    let __v_24: G = G::from_u64(206);
+    let __v_25: G = G::from_u64(200);
+    let __v_26: G = G::from_u64(9);
+    let __v_27: G = G::from_u64(159);
+    let __v_28: G = G::from_u64(174);
+    let __v_29: G = G::from_u64(157);
+    let __v_30: G = G::from_u64(228);
+    let __v_31: G = G::from_u64(228);
     let __v_32: G = { let __values: [G; 32] = [__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]; 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_275] = [__v_32];
-    record.function_queries[275].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_174] = [__v_32];
+    record.function_queries[174].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_276: usize = 0;
-const IN_276: usize = 0;
-const OUT_276: usize = 1;
-fn aiur_fn_276(
-  inp: [G; IN_276],
+const INPUT_SIZE_175: usize = 0;
+const IN_175: usize = 0;
+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_276], ExecError> {
+) -> Result<[G; OUT_175], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(253);
-    let __v_1: G = G::from_u64(189);
-    let __v_2: G = G::from_u64(95);
-    let __v_3: G = G::from_u64(239);
-    let __v_4: G = G::from_u64(64);
-    let __v_5: G = G::from_u64(20);
-    let __v_6: G = G::from_u64(156);
-    let __v_7: G = G::from_u64(133);
-    let __v_8: G = G::from_u64(51);
-    let __v_9: G = G::from_u64(60);
-    let __v_10: G = G::from_u64(111);
-    let __v_11: G = G::from_u64(60);
-    let __v_12: G = G::from_u64(206);
-    let __v_13: G = G::from_u64(187);
-    let __v_14: G = G::from_u64(75);
-    let __v_15: G = G::from_u64(231);
-    let __v_16: G = G::from_u64(65);
-    let __v_17: G = G::from_u64(39);
-    let __v_18: G = G::from_u64(13);
-    let __v_19: G = G::from_u64(32);
-    let __v_20: G = G::from_u64(102);
-    let __v_21: G = G::from_u64(51);
-    let __v_22: G = G::from_u64(108);
-    let __v_23: G = G::from_u64(178);
-    let __v_24: G = G::from_u64(238);
-    let __v_25: G = G::from_u64(248);
-    let __v_26: G = G::from_u64(118);
-    let __v_27: G = G::from_u64(35);
-    let __v_28: G = G::from_u64(116);
-    let __v_29: G = G::from_u64(75);
-    let __v_30: G = G::from_u64(114);
-    let __v_31: G = G::from_u64(176);
+    let __v_0: G = G::from_u64(144);
+    let __v_1: G = G::from_u64(202);
+    let __v_2: G = G::from_u64(129);
+    let __v_3: G = G::from_u64(48);
+    let __v_4: G = G::from_u64(115);
+    let __v_5: G = G::from_u64(92);
+    let __v_6: G = G::from_u64(141);
+    let __v_7: G = G::from_u64(154);
+    let __v_8: G = G::from_u64(52);
+    let __v_9: G = G::from_u64(0);
+    let __v_10: G = G::from_u64(90);
+    let __v_11: G = G::from_u64(137);
+    let __v_12: G = G::from_u64(67);
+    let __v_13: G = G::from_u64(181);
+    let __v_14: G = G::from_u64(159);
+    let __v_15: G = G::from_u64(225);
+    let __v_16: G = G::from_u64(223);
+    let __v_17: G = G::from_u64(24);
+    let __v_18: G = G::from_u64(46);
+    let __v_19: G = G::from_u64(8);
+    let __v_20: G = G::from_u64(169);
+    let __v_21: G = G::from_u64(242);
+    let __v_22: G = G::from_u64(191);
+    let __v_23: G = G::from_u64(199);
+    let __v_24: G = G::from_u64(220);
+    let __v_25: G = G::from_u64(131);
+    let __v_26: G = G::from_u64(35);
+    let __v_27: G = G::from_u64(34);
+    let __v_28: G = G::from_u64(150);
+    let __v_29: G = G::from_u64(89);
+    let __v_30: G = G::from_u64(165);
+    let __v_31: G = G::from_u64(116);
     let __v_32: G = { let __values: [G; 32] = [__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]; 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_276] = [__v_32];
-    record.function_queries[276].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_175] = [__v_32];
+    record.function_queries[175].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_277: usize = 0;
-const IN_277: usize = 0;
-const OUT_277: usize = 1;
-fn aiur_fn_277(
-  inp: [G; IN_277],
+const INPUT_SIZE_176: usize = 0;
+const IN_176: usize = 0;
+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_277], ExecError> {
+) -> Result<[G; OUT_176], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(102);
-    let __v_1: G = G::from_u64(73);
-    let __v_2: G = G::from_u64(102);
-    let __v_3: G = G::from_u64(86);
-    let __v_4: G = G::from_u64(7);
-    let __v_5: G = G::from_u64(176);
-    let __v_6: G = G::from_u64(117);
-    let __v_7: G = G::from_u64(12);
-    let __v_8: G = G::from_u64(44);
-    let __v_9: G = G::from_u64(167);
-    let __v_10: G = G::from_u64(63);
-    let __v_11: G = G::from_u64(69);
-    let __v_12: G = G::from_u64(222);
-    let __v_13: G = G::from_u64(96);
-    let __v_14: G = G::from_u64(15);
-    let __v_15: G = G::from_u64(33);
-    let __v_16: G = G::from_u64(203);
-    let __v_17: G = G::from_u64(103);
-    let __v_18: G = G::from_u64(3);
-    let __v_19: G = G::from_u64(152);
-    let __v_20: G = G::from_u64(80);
-    let __v_21: G = G::from_u64(72);
-    let __v_22: G = G::from_u64(101);
-    let __v_23: G = G::from_u64(187);
-    let __v_24: G = G::from_u64(151);
-    let __v_25: G = G::from_u64(151);
-    let __v_26: G = G::from_u64(36);
-    let __v_27: G = G::from_u64(56);
-    let __v_28: G = G::from_u64(1);
-    let __v_29: G = G::from_u64(79);
-    let __v_30: G = G::from_u64(150);
-    let __v_31: G = G::from_u64(217);
+    let __v_0: G = G::from_u64(105);
+    let __v_1: G = G::from_u64(141);
+    let __v_2: G = G::from_u64(213);
+    let __v_3: G = G::from_u64(147);
+    let __v_4: G = G::from_u64(171);
+    let __v_5: G = G::from_u64(251);
+    let __v_6: G = G::from_u64(99);
+    let __v_7: G = G::from_u64(219);
+    let __v_8: G = G::from_u64(54);
+    let __v_9: G = G::from_u64(42);
+    let __v_10: G = G::from_u64(174);
+    let __v_11: G = G::from_u64(245);
+    let __v_12: G = G::from_u64(126);
+    let __v_13: G = G::from_u64(112);
+    let __v_14: G = G::from_u64(167);
+    let __v_15: G = G::from_u64(147);
+    let __v_16: G = G::from_u64(4);
+    let __v_17: G = G::from_u64(79);
+    let __v_18: G = G::from_u64(182);
+    let __v_19: G = G::from_u64(87);
+    let __v_20: G = G::from_u64(37);
+    let __v_21: G = G::from_u64(114);
+    let __v_22: G = G::from_u64(145);
+    let __v_23: G = G::from_u64(238);
+    let __v_24: G = G::from_u64(44);
+    let __v_25: G = G::from_u64(62);
+    let __v_26: G = G::from_u64(153);
+    let __v_27: G = G::from_u64(124);
+    let __v_28: G = G::from_u64(170);
+    let __v_29: G = G::from_u64(66);
+    let __v_30: G = G::from_u64(62);
+    let __v_31: G = G::from_u64(174);
     let __v_32: G = { let __values: [G; 32] = [__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]; 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_277] = [__v_32];
-    record.function_queries[277].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_176] = [__v_32];
+    record.function_queries[176].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_278: usize = 0;
-const IN_278: usize = 0;
-const OUT_278: usize = 1;
-fn aiur_fn_278(
-  inp: [G; IN_278],
+const INPUT_SIZE_177: usize = 0;
+const IN_177: usize = 0;
+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_278], ExecError> {
+) -> Result<[G; OUT_177], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(51);
-    let __v_1: G = G::from_u64(198);
-    let __v_2: G = G::from_u64(4);
+    let __v_0: G = G::from_u64(159);
+    let __v_1: G = G::from_u64(216);
+    let __v_2: G = G::from_u64(231);
     let __v_3: G = G::from_u64(69);
-    let __v_4: G = G::from_u64(29);
-    let __v_5: G = G::from_u64(1);
-    let __v_6: G = G::from_u64(203);
-    let __v_7: G = G::from_u64(25);
-    let __v_8: G = G::from_u64(164);
-    let __v_9: G = G::from_u64(51);
-    let __v_10: G = G::from_u64(102);
-    let __v_11: G = G::from_u64(130);
-    let __v_12: G = G::from_u64(70);
-    let __v_13: G = G::from_u64(185);
-    let __v_14: G = G::from_u64(143);
-    let __v_15: G = G::from_u64(110);
-    let __v_16: G = G::from_u64(135);
-    let __v_17: G = G::from_u64(75);
-    let __v_18: G = G::from_u64(214);
-    let __v_19: G = G::from_u64(48);
-    let __v_20: G = G::from_u64(183);
-    let __v_21: G = G::from_u64(138);
-    let __v_22: G = G::from_u64(121);
-    let __v_23: G = G::from_u64(29);
-    let __v_24: G = G::from_u64(122);
-    let __v_25: G = G::from_u64(55);
-    let __v_26: G = G::from_u64(58);
-    let __v_27: G = G::from_u64(151);
-    let __v_28: G = G::from_u64(152);
-    let __v_29: G = G::from_u64(73);
-    let __v_30: G = G::from_u64(161);
-    let __v_31: G = G::from_u64(207);
+    let __v_4: G = G::from_u64(154);
+    let __v_5: G = G::from_u64(29);
+    let __v_6: G = G::from_u64(45);
+    let __v_7: G = G::from_u64(238);
+    let __v_8: G = G::from_u64(240);
+    let __v_9: G = G::from_u64(10);
+    let __v_10: G = G::from_u64(73);
+    let __v_11: G = G::from_u64(146);
+    let __v_12: G = G::from_u64(165);
+    let __v_13: G = G::from_u64(4);
+    let __v_14: G = G::from_u64(25);
+    let __v_15: G = G::from_u64(186);
+    let __v_16: G = G::from_u64(198);
+    let __v_17: G = G::from_u64(108);
+    let __v_18: G = G::from_u64(3);
+    let __v_19: G = G::from_u64(8);
+    let __v_20: G = G::from_u64(43);
+    let __v_21: G = G::from_u64(88);
+    let __v_22: G = G::from_u64(173);
+    let __v_23: G = G::from_u64(224);
+    let __v_24: G = G::from_u64(116);
+    let __v_25: G = G::from_u64(34);
+    let __v_26: G = G::from_u64(137);
+    let __v_27: G = G::from_u64(111);
+    let __v_28: G = G::from_u64(19);
+    let __v_29: G = G::from_u64(3);
+    let __v_30: G = G::from_u64(61);
+    let __v_31: G = G::from_u64(116);
     let __v_32: G = { let __values: [G; 32] = [__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]; 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_278] = [__v_32];
-    record.function_queries[278].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_177] = [__v_32];
+    record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_279: usize = 0;
-const IN_279: usize = 0;
-const OUT_279: usize = 1;
-fn aiur_fn_279(
-  inp: [G; IN_279],
+const INPUT_SIZE_178: usize = 0;
+const IN_178: usize = 0;
+const OUT_178: usize = 1;
+fn aiur_fn_178(
+  inp: [G; IN_178],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_279], ExecError> {
+) -> Result<[G; OUT_178], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(59);
-    let __v_1: G = G::from_u64(228);
-    let __v_2: G = G::from_u64(131);
-    let __v_3: G = G::from_u64(87);
-    let __v_4: G = G::from_u64(174);
-    let __v_5: G = G::from_u64(23);
-    let __v_6: G = G::from_u64(247);
-    let __v_7: G = G::from_u64(77);
-    let __v_8: G = G::from_u64(77);
-    let __v_9: G = G::from_u64(242);
-    let __v_10: G = G::from_u64(125);
-    let __v_11: G = G::from_u64(105);
-    let __v_12: G = G::from_u64(122);
-    let __v_13: G = G::from_u64(237);
-    let __v_14: G = G::from_u64(63);
-    let __v_15: G = G::from_u64(71);
-    let __v_16: G = G::from_u64(193);
-    let __v_17: G = G::from_u64(48);
-    let __v_18: G = G::from_u64(121);
-    let __v_19: G = G::from_u64(65);
-    let __v_20: G = G::from_u64(244);
-    let __v_21: G = G::from_u64(26);
-    let __v_22: G = G::from_u64(255);
-    let __v_23: G = G::from_u64(207);
-    let __v_24: G = G::from_u64(116);
-    let __v_25: G = G::from_u64(218);
-    let __v_26: G = G::from_u64(95);
-    let __v_27: G = G::from_u64(102);
-    let __v_28: G = G::from_u64(213);
-    let __v_29: G = G::from_u64(17);
-    let __v_30: G = G::from_u64(167);
-    let __v_31: G = G::from_u64(151);
+    let __v_0: G = G::from_u64(197);
+    let __v_1: G = G::from_u64(247);
+    let __v_2: G = G::from_u64(177);
+    let __v_3: G = G::from_u64(150);
+    let __v_4: G = G::from_u64(99);
+    let __v_5: G = G::from_u64(228);
+    let __v_6: G = G::from_u64(73);
+    let __v_7: G = G::from_u64(158);
+    let __v_8: G = G::from_u64(112);
+    let __v_9: G = G::from_u64(225);
+    let __v_10: G = G::from_u64(178);
+    let __v_11: G = G::from_u64(100);
+    let __v_12: G = G::from_u64(81);
+    let __v_13: G = G::from_u64(98);
+    let __v_14: G = G::from_u64(197);
+    let __v_15: G = G::from_u64(190);
+    let __v_16: G = G::from_u64(21);
+    let __v_17: G = G::from_u64(250);
+    let __v_18: G = G::from_u64(134);
+    let __v_19: G = G::from_u64(15);
+    let __v_20: G = G::from_u64(79);
+    let __v_21: G = G::from_u64(129);
+    let __v_22: G = G::from_u64(87);
+    let __v_23: G = G::from_u64(227);
+    let __v_24: G = G::from_u64(49);
+    let __v_25: G = G::from_u64(174);
+    let __v_26: G = G::from_u64(84);
+    let __v_27: G = G::from_u64(108);
+    let __v_28: G = G::from_u64(111);
+    let __v_29: G = G::from_u64(115);
+    let __v_30: G = G::from_u64(55);
+    let __v_31: G = G::from_u64(35);
     let __v_32: G = { let __values: [G; 32] = [__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]; 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_279] = [__v_32];
-    record.function_queries[279].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_178] = [__v_32];
+    record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_280: usize = 0;
-const IN_280: usize = 0;
-const OUT_280: usize = 1;
-fn aiur_fn_280(
-  inp: [G; IN_280],
+const INPUT_SIZE_179: usize = 0;
+const IN_179: usize = 0;
+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_280], ExecError> {
+) -> Result<[G; OUT_179], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(81);
-    let __v_1: G = G::from_u64(121);
-    let __v_2: G = G::from_u64(99);
-    let __v_3: G = G::from_u64(139);
-    let __v_4: G = G::from_u64(130);
-    let __v_5: G = G::from_u64(204);
-    let __v_6: G = G::from_u64(131);
-    let __v_7: G = G::from_u64(55);
-    let __v_8: G = G::from_u64(145);
-    let __v_9: G = G::from_u64(74);
-    let __v_10: G = G::from_u64(123);
-    let __v_11: G = G::from_u64(202);
-    let __v_12: G = G::from_u64(173);
-    let __v_13: G = G::from_u64(133);
-    let __v_14: G = G::from_u64(140);
-    let __v_15: G = G::from_u64(133);
-    let __v_16: G = G::from_u64(136);
-    let __v_17: G = G::from_u64(136);
-    let __v_18: G = G::from_u64(68);
-    let __v_19: G = G::from_u64(233);
-    let __v_20: G = G::from_u64(162);
-    let __v_21: G = G::from_u64(146);
-    let __v_22: G = G::from_u64(67);
-    let __v_23: G = G::from_u64(12);
-    let __v_24: G = G::from_u64(172);
-    let __v_25: G = G::from_u64(81);
-    let __v_26: G = G::from_u64(229);
-    let __v_27: G = G::from_u64(234);
-    let __v_28: G = G::from_u64(220);
-    let __v_29: G = G::from_u64(65);
-    let __v_30: G = G::from_u64(161);
-    let __v_31: G = G::from_u64(175);
+    let __v_0: G = G::from_u64(202);
+    let __v_1: G = G::from_u64(202);
+    let __v_2: G = G::from_u64(234);
+    let __v_3: G = G::from_u64(151);
+    let __v_4: G = G::from_u64(244);
+    let __v_5: G = G::from_u64(205);
+    let __v_6: G = G::from_u64(186);
+    let __v_7: G = G::from_u64(10);
+    let __v_8: G = G::from_u64(74);
+    let __v_9: G = G::from_u64(10);
+    let __v_10: G = G::from_u64(247);
+    let __v_11: G = G::from_u64(16);
+    let __v_12: G = G::from_u64(5);
+    let __v_13: G = G::from_u64(208);
+    let __v_14: G = G::from_u64(81);
+    let __v_15: G = G::from_u64(125);
+    let __v_16: G = G::from_u64(24);
+    let __v_17: G = G::from_u64(24);
+    let __v_18: G = G::from_u64(171);
+    let __v_19: G = G::from_u64(38);
+    let __v_20: G = G::from_u64(35);
+    let __v_21: G = G::from_u64(189);
+    let __v_22: G = G::from_u64(46);
+    let __v_23: G = G::from_u64(167);
+    let __v_24: G = G::from_u64(250);
+    let __v_25: G = G::from_u64(140);
+    let __v_26: G = G::from_u64(99);
+    let __v_27: G = G::from_u64(122);
+    let __v_28: G = G::from_u64(14);
+    let __v_29: G = G::from_u64(61);
+    let __v_30: G = G::from_u64(51);
+    let __v_31: G = G::from_u64(18);
     let __v_32: G = { let __values: [G; 32] = [__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]; 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_280] = [__v_32];
-    record.function_queries[280].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_179] = [__v_32];
+    record.function_queries[179].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_281: usize = 0;
-const IN_281: usize = 0;
-const OUT_281: usize = 1;
-fn aiur_fn_281(
-  inp: [G; IN_281],
+const INPUT_SIZE_180: usize = 1;
+const IN_180: usize = 1;
+const OUT_180: usize = 1;
+fn aiur_fn_180(
+  inp: [G; IN_180],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_281], ExecError> {
+) -> Result<[G; OUT_180], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(137);
-    let __v_1: G = G::from_u64(222);
-    let __v_2: G = G::from_u64(202);
-    let __v_3: G = G::from_u64(134);
-    let __v_4: G = G::from_u64(221);
-    let __v_5: G = G::from_u64(143);
-    let __v_6: G = G::from_u64(0);
-    let __v_7: G = G::from_u64(102);
-    let __v_8: G = G::from_u64(165);
-    let __v_9: G = G::from_u64(6);
-    let __v_10: G = G::from_u64(79);
-    let __v_11: G = G::from_u64(219);
-    let __v_12: G = G::from_u64(25);
-    let __v_13: G = G::from_u64(162);
-    let __v_14: G = G::from_u64(198);
-    let __v_15: G = G::from_u64(137);
-    let __v_16: G = G::from_u64(122);
-    let __v_17: G = G::from_u64(58);
-    let __v_18: G = G::from_u64(152);
-    let __v_19: G = G::from_u64(103);
-    let __v_20: G = G::from_u64(202);
-    let __v_21: G = G::from_u64(173);
-    let __v_22: G = G::from_u64(192);
-    let __v_23: G = G::from_u64(79);
-    let __v_24: G = G::from_u64(119);
-    let __v_25: G = G::from_u64(141);
-    let __v_26: G = G::from_u64(92);
-    let __v_27: G = G::from_u64(92);
-    let __v_28: G = G::from_u64(208);
-    let __v_29: G = G::from_u64(34);
-    let __v_30: G = G::from_u64(83);
-    let __v_31: G = G::from_u64(98);
-    let __v_32: G = { let __values: [G; 32] = [__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]; 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_281] = [__v_32];
-    record.function_queries[281].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[174].get_mut(&__args[..]) { 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_1: G = __r_arr[0];
+    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_2: G = __r_arr[0];
+    match __v_2.as_canonical_u64() {
+      1u64 => {
+        let __v_3: G = G::from_u64(1);
+        let __ret: [G; OUT_180] = [__v_3];
+        record.function_queries[180].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[177].get_mut(&__args[..]) { 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_3: G = __r_arr[0];
+        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_4: G = __r_arr[0];
+        match __v_4.as_canonical_u64() {
+          1u64 => {
+            let __v_5: G = G::from_u64(1);
+            let __ret: [G; OUT_180] = [__v_5];
+            record.function_queries[180].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[178].get_mut(&__args[..]) { 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 __v_5: G = __r_arr[0];
+            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_6: G = __r_arr[0];
+            match __v_6.as_canonical_u64() {
+              1u64 => {
+                let __v_7: G = G::from_u64(1);
+                let __ret: [G; OUT_180] = [__v_7];
+                record.function_queries[180].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                let __v_7: G = G::from_u64(0);
+                let __ret: [G; OUT_180] = [__v_7];
+                record.function_queries[180].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+            }
+          },
+        }
+      },
+    }
   })
 }
 
-const INPUT_SIZE_282: usize = 0;
-const IN_282: usize = 0;
-const OUT_282: usize = 1;
-fn aiur_fn_282(
-  inp: [G; IN_282],
+const INPUT_SIZE_181: usize = 1;
+const IN_181: usize = 1;
+const OUT_181: usize = 1;
+fn aiur_fn_181(
+  inp: [G; IN_181],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_282], ExecError> {
+) -> Result<[G; OUT_181], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(129);
-    let __v_1: G = G::from_u64(138);
-    let __v_2: G = G::from_u64(187);
-    let __v_3: G = G::from_u64(51);
-    let __v_4: G = G::from_u64(17);
-    let __v_5: G = G::from_u64(80);
-    let __v_6: G = G::from_u64(64);
-    let __v_7: G = G::from_u64(13);
-    let __v_8: G = G::from_u64(16);
-    let __v_9: G = G::from_u64(179);
-    let __v_10: G = G::from_u64(79);
-    let __v_11: G = G::from_u64(174);
-    let __v_12: G = G::from_u64(77);
-    let __v_13: G = G::from_u64(251);
-    let __v_14: G = G::from_u64(148);
-    let __v_15: G = G::from_u64(38);
-    let __v_16: G = G::from_u64(116);
-    let __v_17: G = G::from_u64(28);
-    let __v_18: G = G::from_u64(70);
-    let __v_19: G = G::from_u64(7);
-    let __v_20: G = G::from_u64(186);
-    let __v_21: G = G::from_u64(238);
-    let __v_22: G = G::from_u64(216);
-    let __v_23: G = G::from_u64(217);
-    let __v_24: G = G::from_u64(98);
-    let __v_25: G = G::from_u64(113);
-    let __v_26: G = G::from_u64(186);
-    let __v_27: G = G::from_u64(22);
-    let __v_28: G = G::from_u64(89);
-    let __v_29: G = G::from_u64(5);
-    let __v_30: G = G::from_u64(142);
-    let __v_31: G = G::from_u64(248);
-    let __v_32: G = { let __values: [G; 32] = [__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]; 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_282] = [__v_32];
-    record.function_queries[282].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
+    let __v_0: G = inp[0];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __v_1: G = G::from_u64(2);
+        let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { 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_2: G = __r_arr[0];
+        let __v_3: G = G::from_u64(1);
+        let __v_4: G = G::from_u64(1);
+        let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __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_6: G = G::from_u64(0);
+        let __v_7: G = { let __values: [G; 4] = [__v_1, __v_2, __v_5, __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_181] = [__v_7];
+        record.function_queries[181].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __v_1: G = G::from_u64(2);
+        let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[155].get_mut(&__args[..]) { 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_2: G = __r_arr[0];
+        let __v_3: G = G::from_u64(1);
+        let __v_4: G = G::from_u64(1);
+        let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __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_6: G = G::from_u64(0);
+        let __v_7: G = { let __values: [G; 4] = [__v_1, __v_2, __v_5, __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_181] = [__v_7];
+        record.function_queries[181].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+    }
   })
 }
 
-const INPUT_SIZE_283: usize = 0;
-const IN_283: usize = 0;
-const OUT_283: usize = 1;
-fn aiur_fn_283(
-  inp: [G; IN_283],
+const INPUT_SIZE_182: usize = 2;
+const IN_182: usize = 2;
+const OUT_182: usize = 2;
+fn aiur_fn_182(
+  inp: [G; IN_182],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_283], ExecError> {
+) -> Result<[G; OUT_182], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(155);
-    let __v_1: G = G::from_u64(118);
-    let __v_2: G = G::from_u64(243);
-    let __v_3: G = G::from_u64(43);
-    let __v_4: G = G::from_u64(187);
-    let __v_5: G = G::from_u64(29);
-    let __v_6: G = G::from_u64(189);
-    let __v_7: G = G::from_u64(244);
-    let __v_8: G = G::from_u64(255);
-    let __v_9: G = G::from_u64(104);
-    let __v_10: G = G::from_u64(224);
-    let __v_11: G = G::from_u64(34);
-    let __v_12: G = G::from_u64(18);
-    let __v_13: G = G::from_u64(37);
-    let __v_14: G = G::from_u64(1);
-    let __v_15: G = G::from_u64(93);
-    let __v_16: G = G::from_u64(240);
-    let __v_17: G = G::from_u64(202);
-    let __v_18: G = G::from_u64(45);
-    let __v_19: G = G::from_u64(42);
-    let __v_20: G = G::from_u64(96);
-    let __v_21: G = G::from_u64(35);
-    let __v_22: G = G::from_u64(193);
-    let __v_23: G = G::from_u64(168);
-    let __v_24: G = G::from_u64(19);
-    let __v_25: G = G::from_u64(6);
-    let __v_26: G = G::from_u64(212);
-    let __v_27: G = G::from_u64(2);
-    let __v_28: G = G::from_u64(13);
-    let __v_29: G = G::from_u64(78);
-    let __v_30: G = G::from_u64(243);
-    let __v_31: G = G::from_u64(151);
-    let __v_32: G = { let __values: [G; 32] = [__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]; 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_283] = [__v_32];
-    record.function_queries[283].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[185].get_mut(&__args[..]) { 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_2: G = __r_arr[0];
+    let __v_3: G = __r_arr[1];
+    let __v_4: G = __r_arr[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 = G::from_u64(1);
+        let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; 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_182] = [__v_5, __v_8];
+        record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      1u64 => {
+        let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[225].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_225] = unsafe { *(result.output.as_ptr() as *const [G; OUT_225]) }; __ret } else { aiur_fn_225(__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(0);
+            let __v_8: G = G::from_u64(1);
+            let __v_9: G = G::from_u64(1);
+            let __v_10: G = { let __values: [G; 10] = [__v_8, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9]; 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_182] = [__v_7, __v_10];
+            record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          1u64 => {
+            let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[225].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_225] = unsafe { *(result.output.as_ptr() as *const [G; OUT_225]) }; __ret } else { aiur_fn_225(__args, record, io_buffer, __cu)? } };
+            let __v_7: G = __r_arr[0];
+            let __v_8: G = __r_arr[1];
+            match __v_7.as_canonical_u64() {
+              0u64 => {
+                let __v_9: G = G::from_u64(0);
+                let __v_10: G = G::from_u64(1);
+                let __v_11: G = G::from_u64(1);
+                let __v_12: G = { let __values: [G; 10] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; 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_182] = [__v_9, __v_12];
+                record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              1u64 => {
+                let __v_9: G = G::from_u64(0);
+                let __v_10: G = G::from_u64(2);
+                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 = G::from_u64(0);
+                let __v_18: G = G::from_u64(1);
+                let __v_19: G = G::from_u64(1);
+                let __v_20: G = { let __values: [G; 10] = [__v_18, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19]; 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_21: G = { let __values: [G; 10] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_20]; 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_129] = { let __args: [G; IN_129] = [__v_21, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { 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_22: G = __r_arr[0];
+                let __v_23: G = G::from_u64(1);
+                let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_6, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { 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_24: G = __r_arr[0];
+                let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { 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_25: G = __r_arr[0];
+                let __ret: [G; OUT_182] = [__v_23, __v_25];
+                record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64()));
+              },
+            }
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
   })
 }
 
-const INPUT_SIZE_284: usize = 0;
-const IN_284: usize = 0;
-const OUT_284: usize = 1;
-fn aiur_fn_284(
-  inp: [G; IN_284],
+const INPUT_SIZE_183: usize = 1;
+const IN_183: usize = 1;
+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_284], ExecError> {
+) -> Result<[G; OUT_183], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(151);
-    let __v_1: G = G::from_u64(227);
-    let __v_2: G = G::from_u64(37);
-    let __v_3: G = G::from_u64(169);
-    let __v_4: G = G::from_u64(106);
-    let __v_5: G = G::from_u64(106);
-    let __v_6: G = G::from_u64(24);
-    let __v_7: G = G::from_u64(39);
-    let __v_8: G = G::from_u64(25);
-    let __v_9: G = G::from_u64(78);
-    let __v_10: G = G::from_u64(235);
-    let __v_11: G = G::from_u64(125);
-    let __v_12: G = G::from_u64(42);
-    let __v_13: G = G::from_u64(160);
-    let __v_14: G = G::from_u64(217);
-    let __v_15: G = G::from_u64(25);
-    let __v_16: G = G::from_u64(33);
-    let __v_17: G = G::from_u64(7);
-    let __v_18: G = G::from_u64(58);
-    let __v_19: G = G::from_u64(239);
-    let __v_20: G = G::from_u64(156);
-    let __v_21: G = G::from_u64(45);
-    let __v_22: G = G::from_u64(51);
-    let __v_23: G = G::from_u64(60);
-    let __v_24: G = G::from_u64(36);
-    let __v_25: G = G::from_u64(97);
-    let __v_26: G = G::from_u64(62);
-    let __v_27: G = G::from_u64(154);
-    let __v_28: G = G::from_u64(201);
-    let __v_29: G = G::from_u64(86);
-    let __v_30: G = G::from_u64(237);
-    let __v_31: G = G::from_u64(41);
-    let __v_32: G = { let __values: [G; 32] = [__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]; 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_284] = [__v_32];
-    record.function_queries[284].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } else { aiur_fn_711(__args, record, io_buffer, __cu)? } };
+    let __v_1: G = __r_arr[0];
+    let __v_2: G = G::from_u64(3);
+    let __v_3: G = { let __a_val = __v_1.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_3.as_canonical_u64() {
+      1u64 => {
+        let __v_4: G = G::from_u64(0);
+        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 = { let __values: [G; 4] = [__v_5, __v_6, __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_183] = [__v_4, __v_8];
+        record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __v_4: G = G::from_u64(0);
+        let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } };
+        let __v_5: G = __r_arr[0];
+        let __v_6: G = G::from_u64(1);
+        let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } };
+        let __v_7: G = __r_arr[0];
+        let __v_8: G = G::from_u64(2);
+        let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } };
+        let __v_9: G = __r_arr[0];
+        let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[182].get_mut(&__args[..]) { 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_10: G = __r_arr[0];
+        let __v_11: G = __r_arr[1];
+        match __v_10.as_canonical_u64() {
+          0u64 => {
+            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 = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; 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_183] = [__v_12, __v_16];
+            record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          1u64 => {
+            let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[182].get_mut(&__args[..]) { 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 = __r_arr[1];
+            match __v_12.as_canonical_u64() {
+              0u64 => {
+                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 = G::from_u64(0);
+                let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; 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_183] = [__v_14, __v_18];
+                record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              1u64 => {
+                let __v_14: G = G::from_u64(1);
+                let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_13, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { 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_15: G = __r_arr[0];
+                let __v_16: G = (__v_14 - __v_15);
+                let __v_17: G = G::from_u64(1);
+                let __r_arr: [G; OUT_181] = { let __args: [G; IN_181] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[181].get_mut(&__args[..]) { 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_18: G = __r_arr[0];
+                let __ret: [G; OUT_183] = [__v_17, __v_18];
+                record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64()));
+              },
+            }
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64()));
+          },
+        }
+      },
+    }
   })
 }
 
-const INPUT_SIZE_285: usize = 0;
-const IN_285: usize = 0;
-const OUT_285: usize = 1;
-fn aiur_fn_285(
-  inp: [G; IN_285],
+const INPUT_SIZE_184: usize = 1;
+const IN_184: usize = 1;
+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_285], ExecError> {
+) -> Result<[G; OUT_184], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(220);
-    let __v_1: G = G::from_u64(129);
-    let __v_2: G = G::from_u64(228);
-    let __v_3: G = G::from_u64(28);
-    let __v_4: G = G::from_u64(173);
-    let __v_5: G = G::from_u64(17);
-    let __v_6: G = G::from_u64(144);
-    let __v_7: G = G::from_u64(55);
-    let __v_8: G = G::from_u64(125);
-    let __v_9: G = G::from_u64(190);
-    let __v_10: G = G::from_u64(96);
-    let __v_11: G = G::from_u64(75);
-    let __v_12: G = G::from_u64(252);
-    let __v_13: G = G::from_u64(58);
-    let __v_14: G = G::from_u64(254);
-    let __v_15: G = G::from_u64(101);
-    let __v_16: G = G::from_u64(138);
-    let __v_17: G = G::from_u64(65);
-    let __v_18: G = G::from_u64(59);
-    let __v_19: G = G::from_u64(154);
-    let __v_20: G = G::from_u64(45);
-    let __v_21: G = G::from_u64(207);
-    let __v_22: G = G::from_u64(188);
-    let __v_23: G = G::from_u64(171);
-    let __v_24: G = G::from_u64(121);
-    let __v_25: G = G::from_u64(250);
-    let __v_26: G = G::from_u64(215);
-    let __v_27: G = G::from_u64(183);
-    let __v_28: G = G::from_u64(165);
-    let __v_29: G = G::from_u64(205);
-    let __v_30: G = G::from_u64(217);
-    let __v_31: G = G::from_u64(84);
-    let __v_32: G = { let __values: [G; 32] = [__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]; 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_285] = [__v_32];
-    record.function_queries[285].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } else { aiur_fn_711(__args, record, io_buffer, __cu)? } };
+    let __v_1: G = __r_arr[0];
+    let __v_2: G = G::from_u64(2);
+    let __v_3: G = { let __a_val = __v_1.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_3.as_canonical_u64() {
+      1u64 => {
+        let __v_4: G = G::from_u64(0);
+        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 = { let __values: [G; 4] = [__v_5, __v_6, __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_184] = [__v_4, __v_8];
+        record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __v_4: G = G::from_u64(0);
+        let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } };
+        let __v_5: G = __r_arr[0];
+        let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[106].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_106] = unsafe { *(result.output.as_ptr() as *const [G; OUT_106]) }; __ret } else { aiur_fn_106(__args, record, io_buffer, __cu)? } };
+        let __v_6: G = __r_arr[0];
+        let __v_7: G = __r_arr[1];
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; 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: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].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];
+        match __v_8.as_canonical_u64() {
+          2u64 => {
+            let __r_arr: [G; OUT_179] = { let __args: [G; IN_179] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[179].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_179] = unsafe { *(result.output.as_ptr() as *const [G; OUT_179]) }; __ret } else { aiur_fn_179(__args, record, io_buffer, __cu)? } };
+            let __v_12: G = __r_arr[0];
+            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_9, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_13: G = __r_arr[0];
+            match __v_13.as_canonical_u64() {
+              0u64 => {
+                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 = G::from_u64(0);
+                let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; 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_184] = [__v_14, __v_18];
+                record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } else { aiur_fn_711(__args, record, io_buffer, __cu)? } };
+                let __v_14: G = __r_arr[0];
+                let __v_15: G = G::from_u64(4);
+                let __v_16: G = { let __a_val = __v_14.as_canonical_u64(); let __b_val = __v_15.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_16.as_canonical_u64() {
+                  1u64 => {
+                    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 = { let __values: [G; 4] = [__v_18, __v_19, __v_20, __v_20]; 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_184] = [__v_17, __v_21];
+                    record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
+                  },
+                  _ => {
+                    let __v_17: G = G::from_u64(0);
+                    let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_7, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } };
+                    let __v_18: G = __r_arr[0];
+                    let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[106].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_106] = unsafe { *(result.output.as_ptr() as *const [G; OUT_106]) }; __ret } else { aiur_fn_106(__args, record, io_buffer, __cu)? } };
+                    let __v_19: G = __r_arr[0];
+                    let __v_20: G = __r_arr[1];
+                    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; 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: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+                    let __v_21: G = __loaded[0];
+                    let __v_22: G = __loaded[1];
+                    let __v_23: G = __loaded[2];
+                    let __v_24: G = __loaded[3];
+                    match __v_21.as_canonical_u64() {
+                      2u64 => {
+                        let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[176].get_mut(&__args[..]) { 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_25: G = __r_arr[0];
+                        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_22, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_26: G = __r_arr[0];
+                        match __v_26.as_canonical_u64() {
+                          0u64 => {
+                            let __v_27: G = G::from_u64(0);
+                            let __v_28: G = G::from_u64(0);
+                            let __v_29: G = G::from_u64(0);
+                            let __v_30: G = G::from_u64(0);
+                            let __v_31: G = { let __values: [G; 4] = [__v_28, __v_29, __v_30, __v_30]; 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_184] = [__v_27, __v_31];
+                            record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            return Ok(__ret);
+                          },
+                          _ => {
+                            let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } else { aiur_fn_711(__args, record, io_buffer, __cu)? } };
+                            let __v_27: G = __r_arr[0];
+                            let __v_28: G = G::from_u64(1);
+                            let __v_29: G = { let __a_val = __v_27.as_canonical_u64(); let __b_val = __v_28.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_29.as_canonical_u64() {
+                              1u64 => {
+                                let __v_30: G = G::from_u64(0);
+                                let __v_31: G = G::from_u64(0);
+                                let __v_32: G = G::from_u64(0);
+                                let __v_33: G = G::from_u64(0);
+                                let __v_34: G = { let __values: [G; 4] = [__v_31, __v_32, __v_33, __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_184] = [__v_30, __v_34];
+                                record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                return Ok(__ret);
+                              },
+                              _ => {
+                                let __v_30: G = G::from_u64(0);
+                                let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_20, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } };
+                                let __v_31: G = __r_arr[0];
+                                let __v_32: G = G::from_u64(2);
+                                let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_7, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } };
+                                let __v_33: G = __r_arr[0];
+                                let __v_34: G = G::from_u64(3);
+                                let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_7, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } };
+                                let __v_35: G = __r_arr[0];
+                                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(1);
+                                let __v_40: G = G::from_u64(1);
+                                let __v_41: G = { let __values: [G; 3] = [__v_39, __v_40, __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_38, __v_35, __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 __v_43: G = { let __values: [G; 3] = [__v_37, __v_33, __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_31, __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 __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[183].get_mut(&__args[..]) { 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_45: G = __r_arr[0];
+                                let __v_46: G = __r_arr[1];
+                                let __ret: [G; OUT_184] = [__v_45, __v_46];
+                                record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                return Ok(__ret);
+                              },
+                            }
+                          },
+                        }
+                      },
+                      _ => {
+                        let __v_25: G = G::from_u64(0);
+                        let __v_26: G = G::from_u64(0);
+                        let __v_27: G = G::from_u64(0);
+                        let __v_28: G = G::from_u64(0);
+                        let __v_29: G = { let __values: [G; 4] = [__v_26, __v_27, __v_28, __v_28]; 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_184] = [__v_25, __v_29];
+                        record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        return Ok(__ret);
+                      },
+                    }
+                  },
+                }
+              },
+            }
+          },
+          _ => {
+            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 = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; 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_184] = [__v_12, __v_16];
+            record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+        }
+      },
+    }
   })
 }
 
-const INPUT_SIZE_286: usize = 0;
-const IN_286: usize = 0;
-const OUT_286: usize = 1;
-fn aiur_fn_286(
-  inp: [G; IN_286],
+const INPUT_SIZE_185: usize = 1;
+const IN_185: usize = 1;
+const OUT_185: usize = 3;
+fn aiur_fn_185(
+  inp: [G; IN_185],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_286], ExecError> {
+) -> Result<[G; OUT_185], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(109);
-    let __v_1: G = G::from_u64(180);
-    let __v_2: G = G::from_u64(147);
-    let __v_3: G = G::from_u64(4);
-    let __v_4: G = G::from_u64(191);
-    let __v_5: G = G::from_u64(15);
-    let __v_6: G = G::from_u64(90);
-    let __v_7: G = G::from_u64(203);
-    let __v_8: G = G::from_u64(253);
-    let __v_9: G = G::from_u64(29);
-    let __v_10: G = G::from_u64(157);
-    let __v_11: G = G::from_u64(154);
-    let __v_12: G = G::from_u64(12);
-    let __v_13: G = G::from_u64(27);
-    let __v_14: G = G::from_u64(122);
-    let __v_15: G = G::from_u64(226);
-    let __v_16: G = G::from_u64(14);
-    let __v_17: G = G::from_u64(249);
-    let __v_18: G = G::from_u64(157);
-    let __v_19: G = G::from_u64(7);
-    let __v_20: G = G::from_u64(55);
-    let __v_21: G = G::from_u64(136);
-    let __v_22: G = G::from_u64(112);
-    let __v_23: G = G::from_u64(86);
-    let __v_24: G = G::from_u64(18);
-    let __v_25: G = G::from_u64(159);
-    let __v_26: G = G::from_u64(91);
-    let __v_27: G = G::from_u64(92);
-    let __v_28: G = G::from_u64(181);
-    let __v_29: G = G::from_u64(169);
-    let __v_30: G = G::from_u64(186);
-    let __v_31: G = G::from_u64(138);
-    let __v_32: G = { let __values: [G; 32] = [__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]; 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_286] = [__v_32];
-    record.function_queries[286].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[106].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_106] = unsafe { *(result.output.as_ptr() as *const [G; OUT_106]) }; __ret } else { aiur_fn_106(__args, record, io_buffer, __cu)? } };
+    let __v_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    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_3: G = __loaded[0];
+    let __v_4: G = __loaded[1];
+    let __v_5: G = __loaded[2];
+    let __v_6: G = __loaded[3];
+    match __v_3.as_canonical_u64() {
+      2u64 => {
+        let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[175].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_175] = unsafe { *(result.output.as_ptr() as *const [G; OUT_175]) }; __ret } else { aiur_fn_175(__args, record, io_buffer, __cu)? } };
+        let __v_7: G = __r_arr[0];
+        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_8: G = __r_arr[0];
+        match __v_8.as_canonical_u64() {
+          1u64 => {
+            let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } else { aiur_fn_711(__args, record, io_buffer, __cu)? } };
+            let __v_9: G = __r_arr[0];
+            let __v_10: G = G::from_u64(2);
+            let __v_11: G = (__v_9 - __v_10);
+            match __v_11.as_canonical_u64() {
+              0u64 => {
+                let __v_12: G = G::from_u64(1);
+                let __v_13: G = G::from_u64(0);
+                let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_2, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } };
+                let __v_14: G = __r_arr[0];
+                let __v_15: G = G::from_u64(1);
+                let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_2, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } };
+                let __v_16: G = __r_arr[0];
+                let __ret: [G; OUT_185] = [__v_12, __v_14, __v_16];
+                record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                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 = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; 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_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 = { let __values: [G; 4] = [__v_17, __v_18, __v_19, __v_19]; 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_185] = [__v_12, __v_16, __v_20];
+                record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+            }
+          },
+          _ => {
+            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 = { let __values: [G; 4] = [__v_10, __v_11, __v_12, __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 __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; 4] = [__v_14, __v_15, __v_16, __v_16]; 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_185] = [__v_9, __v_13, __v_17];
+            record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+        }
+      },
+      _ => {
+        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 = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __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 __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 = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; 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_185] = [__v_7, __v_11, __v_15];
+        record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+    }
   })
 }
 
-const INPUT_SIZE_287: usize = 0;
-const IN_287: usize = 0;
-const OUT_287: usize = 1;
-fn aiur_fn_287(
-  inp: [G; IN_287],
+const INPUT_SIZE_186: usize = 3;
+const IN_186: usize = 3;
+const OUT_186: usize = 2;
+fn aiur_fn_186(
+  inp: [G; IN_186],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_287], ExecError> {
+) -> Result<[G; OUT_186], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(163);
-    let __v_1: G = G::from_u64(74);
-    let __v_2: G = G::from_u64(178);
-    let __v_3: G = G::from_u64(218);
-    let __v_4: G = G::from_u64(186);
-    let __v_5: G = G::from_u64(52);
-    let __v_6: G = G::from_u64(131);
-    let __v_7: G = G::from_u64(158);
-    let __v_8: G = G::from_u64(133);
-    let __v_9: G = G::from_u64(31);
-    let __v_10: G = G::from_u64(163);
-    let __v_11: G = G::from_u64(103);
-    let __v_12: G = G::from_u64(81);
-    let __v_13: G = G::from_u64(36);
-    let __v_14: G = G::from_u64(86);
-    let __v_15: G = G::from_u64(111);
-    let __v_16: G = G::from_u64(159);
-    let __v_17: G = G::from_u64(77);
-    let __v_18: G = G::from_u64(205);
-    let __v_19: G = G::from_u64(229);
-    let __v_20: G = G::from_u64(151);
-    let __v_21: G = G::from_u64(52);
-    let __v_22: G = G::from_u64(158);
-    let __v_23: G = G::from_u64(205);
-    let __v_24: G = G::from_u64(84);
-    let __v_25: G = G::from_u64(174);
-    let __v_26: G = G::from_u64(50);
-    let __v_27: G = G::from_u64(248);
-    let __v_28: G = G::from_u64(66);
-    let __v_29: G = G::from_u64(78);
-    let __v_30: G = G::from_u64(68);
-    let __v_31: G = G::from_u64(184);
-    let __v_32: G = { let __values: [G; 32] = [__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]; 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_287] = [__v_32];
-    record.function_queries[287].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[174].get_mut(&__args[..]) { 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_3: G = __r_arr[0];
+    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_4: G = __r_arr[0];
+    match __v_4.as_canonical_u64() {
+      1u64 => {
+        let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } else { aiur_fn_711(__args, record, io_buffer, __cu)? } };
+        let __v_5: G = __r_arr[0];
+        let __v_6: G = G::from_u64(2);
+        let __v_7: G = { let __a_val = __v_5.as_canonical_u64(); let __b_val = __v_6.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_7.as_canonical_u64() {
+          1u64 => {
+            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 = { let __values: [G; 4] = [__v_9, __v_10, __v_11, __v_11]; 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, __v_12];
+            record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[350].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_350] = unsafe { *(result.output.as_ptr() as *const [G; OUT_350]) }; __ret } else { aiur_fn_350(__args, record, io_buffer, __cu)? } };
+            let __v_8: G = __r_arr[0];
+            let __v_9: G = G::from_u64(0);
+            let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } };
+            let __v_10: G = __r_arr[0];
+            let __v_11: G = G::from_u64(1);
+            let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } };
+            let __v_12: G = __r_arr[0];
+            let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[182].get_mut(&__args[..]) { 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_13: G = __r_arr[0];
+            let __v_14: G = __r_arr[1];
+            match __v_13.as_canonical_u64() {
+              0u64 => {
+                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 = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; 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_15, __v_19];
+                record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              1u64 => {
+                let __v_15: G = G::from_u64(1);
+                let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } else { aiur_fn_227(__args, record, io_buffer, __cu)? } };
+                let __v_16: G = __r_arr[0];
+                let __ret: [G; OUT_186] = [__v_15, __v_16];
+                record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64()));
+              },
+            }
+          },
+        }
+      },
+      _ => {
+        let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[177].get_mut(&__args[..]) { 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_5: G = __r_arr[0];
+        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_6: G = __r_arr[0];
+        match __v_6.as_canonical_u64() {
+          1u64 => {
+            let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { 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_7: G = __r_arr[0];
+            let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[183].get_mut(&__args[..]) { 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_8: G = __r_arr[0];
+            let __v_9: G = __r_arr[1];
+            let __ret: [G; OUT_186] = [__v_8, __v_9];
+            record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[178].get_mut(&__args[..]) { 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 __v_7: G = __r_arr[0];
+            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_8: G = __r_arr[0];
+            match __v_8.as_canonical_u64() {
+              1u64 => {
+                let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[184].get_mut(&__args[..]) { 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_9: G = __r_arr[0];
+                let __v_10: G = __r_arr[1];
+                let __ret: [G; OUT_186] = [__v_9, __v_10];
+                record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                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 = { let __values: [G; 4] = [__v_10, __v_11, __v_12, __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_186] = [__v_9, __v_13];
+                record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+            }
+          },
+        }
+      },
+    }
   })
 }
 
-const INPUT_SIZE_288: usize = 0;
-const IN_288: usize = 0;
-const OUT_288: usize = 1;
-fn aiur_fn_288(
-  inp: [G; IN_288],
+const INPUT_SIZE_187: usize = 2;
+const IN_187: usize = 2;
+const OUT_187: usize = 1;
+fn aiur_fn_187(
+  inp: [G; IN_187],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_288], ExecError> {
+) -> Result<[G; OUT_187], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(222);
-    let __v_1: G = G::from_u64(11);
-    let __v_2: G = G::from_u64(239);
-    let __v_3: G = G::from_u64(168);
-    let __v_4: G = G::from_u64(79);
-    let __v_5: G = G::from_u64(170);
-    let __v_6: G = G::from_u64(34);
-    let __v_7: G = G::from_u64(209);
-    let __v_8: G = G::from_u64(57);
-    let __v_9: G = G::from_u64(67);
-    let __v_10: G = G::from_u64(121);
-    let __v_11: G = G::from_u64(160);
-    let __v_12: G = G::from_u64(186);
-    let __v_13: G = G::from_u64(103);
-    let __v_14: G = G::from_u64(41);
-    let __v_15: G = G::from_u64(110);
-    let __v_16: G = G::from_u64(17);
-    let __v_17: G = G::from_u64(102);
-    let __v_18: G = G::from_u64(96);
-    let __v_19: G = G::from_u64(247);
-    let __v_20: G = G::from_u64(129);
-    let __v_21: G = G::from_u64(180);
-    let __v_22: G = G::from_u64(235);
-    let __v_23: G = G::from_u64(99);
-    let __v_24: G = G::from_u64(157);
-    let __v_25: G = G::from_u64(187);
-    let __v_26: G = G::from_u64(171);
-    let __v_27: G = G::from_u64(162);
-    let __v_28: G = G::from_u64(0);
-    let __v_29: G = G::from_u64(239);
-    let __v_30: G = G::from_u64(43);
-    let __v_31: G = G::from_u64(248);
-    let __v_32: G = { let __values: [G; 32] = [__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]; 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_288] = [__v_32];
-    record.function_queries[288].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __r_arr: [G; OUT_348] = { let __args: [G; IN_348] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[348].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_348] = unsafe { *(result.output.as_ptr() as *const [G; OUT_348]) }; __ret } else { aiur_fn_348(__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];
+    let __v_4: G = __loaded[1];
+    let __v_5: G = __loaded[2];
+    match __v_3.as_canonical_u64() {
+      1u64 => {
+        let __ret: [G; OUT_187] = [__v_2];
+        record.function_queries[187].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_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_6: G = __loaded[0];
+        let __v_7: G = __loaded[1];
+        let __v_8: G = __loaded[2];
+        match __v_6.as_canonical_u64() {
+          1u64 => {
+            let __ret: [G; OUT_187] = [__v_2];
+            record.function_queries[187].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_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).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() {
+              1u64 => {
+                let __ret: [G; OUT_187] = [__v_2];
+                record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              0u64 => {
+                let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[188].get_mut(&__args[..]) { 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 __v_12: G = __r_arr[0];
+                let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = [__v_10, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[188].get_mut(&__args[..]) { 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 __v_13: G = __r_arr[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_13, __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 __v_18: G = { let __values: [G; 3] = [__v_15, __v_12, __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_4, __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 __ret: [G; OUT_187] = [__v_19];
+                record.function_queries[187].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()));
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
+      },
+    }
   })
 }
 
-const INPUT_SIZE_289: usize = 0;
-const IN_289: usize = 0;
-const OUT_289: usize = 1;
-fn aiur_fn_289(
-  inp: [G; IN_289],
+const INPUT_SIZE_188: usize = 2;
+const IN_188: usize = 2;
+const OUT_188: usize = 1;
+fn aiur_fn_188(
+  inp: [G; IN_188],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_289], ExecError> {
+) -> Result<[G; OUT_188], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(122);
-    let __v_1: G = G::from_u64(178);
-    let __v_2: G = G::from_u64(213);
-    let __v_3: G = G::from_u64(42);
-    let __v_4: G = G::from_u64(197);
-    let __v_5: G = G::from_u64(47);
-    let __v_6: G = G::from_u64(209);
-    let __v_7: G = G::from_u64(245);
-    let __v_8: G = G::from_u64(24);
-    let __v_9: G = G::from_u64(9);
-    let __v_10: G = G::from_u64(183);
-    let __v_11: G = G::from_u64(24);
-    let __v_12: G = G::from_u64(229);
-    let __v_13: G = G::from_u64(60);
-    let __v_14: G = G::from_u64(208);
-    let __v_15: G = G::from_u64(88);
-    let __v_16: G = G::from_u64(172);
-    let __v_17: G = G::from_u64(75);
-    let __v_18: G = G::from_u64(80);
-    let __v_19: G = G::from_u64(214);
-    let __v_20: G = G::from_u64(81);
-    let __v_21: G = G::from_u64(80);
-    let __v_22: G = G::from_u64(231);
-    let __v_23: G = G::from_u64(138);
-    let __v_24: G = G::from_u64(230);
-    let __v_25: G = G::from_u64(25);
-    let __v_26: G = G::from_u64(19);
-    let __v_27: G = G::from_u64(156);
-    let __v_28: G = G::from_u64(207);
-    let __v_29: G = G::from_u64(19);
-    let __v_30: G = G::from_u64(200);
-    let __v_31: G = G::from_u64(253);
-    let __v_32: G = { let __values: [G; 32] = [__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]; 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_289] = [__v_32];
-    record.function_queries[289].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[106].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_106] = unsafe { *(result.output.as_ptr() as *const [G; OUT_106]) }; __ret } else { aiur_fn_106(__args, record, io_buffer, __cu)? } };
+    let __v_2: G = __r_arr[0];
+    let __v_3: G = __r_arr[1];
+    let __r_arr: [G; OUT_348] = { let __args: [G; IN_348] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[348].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_348] = unsafe { *(result.output.as_ptr() as *const [G; OUT_348]) }; __ret } else { aiur_fn_348(__args, record, io_buffer, __cu)? } };
+    let __v_4: G = __r_arr[0];
+    let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } };
+    let __v_5: G = __r_arr[0];
+    let __ret: [G; OUT_188] = [__v_5];
+    record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_290: usize = 0;
-const IN_290: usize = 0;
-const OUT_290: usize = 1;
-fn aiur_fn_290(
-  inp: [G; IN_290],
+const INPUT_SIZE_189: usize = 0;
+const IN_189: usize = 0;
+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_290], ExecError> {
+) -> Result<[G; OUT_189], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(222);
     let __v_1: G = G::from_u64(244);
@@ -27253,21 +18304,315 @@ fn aiur_fn_290(
     let __v_30: G = G::from_u64(234);
     let __v_31: G = G::from_u64(147);
     let __v_32: G = { let __values: [G; 32] = [__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]; 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_290] = [__v_32];
-    record.function_queries[290].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_189] = [__v_32];
+    record.function_queries[189].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_291: usize = 0;
-const IN_291: usize = 0;
-const OUT_291: usize = 1;
-fn aiur_fn_291(
-  inp: [G; IN_291],
+const INPUT_SIZE_190: usize = 0;
+const IN_190: usize = 0;
+const OUT_190: usize = 1;
+fn aiur_fn_190(
+  inp: [G; IN_190],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_291], ExecError> {
+) -> Result<[G; OUT_190], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = G::from_u64(89);
+    let __v_1: G = G::from_u64(79);
+    let __v_2: G = G::from_u64(177);
+    let __v_3: G = G::from_u64(238);
+    let __v_4: G = G::from_u64(222);
+    let __v_5: G = G::from_u64(199);
+    let __v_6: G = G::from_u64(201);
+    let __v_7: G = G::from_u64(57);
+    let __v_8: G = G::from_u64(204);
+    let __v_9: G = G::from_u64(135);
+    let __v_10: G = G::from_u64(43);
+    let __v_11: G = G::from_u64(108);
+    let __v_12: G = G::from_u64(4);
+    let __v_13: G = G::from_u64(204);
+    let __v_14: G = G::from_u64(59);
+    let __v_15: G = G::from_u64(62);
+    let __v_16: G = G::from_u64(10);
+    let __v_17: G = G::from_u64(151);
+    let __v_18: G = G::from_u64(100);
+    let __v_19: G = G::from_u64(250);
+    let __v_20: G = G::from_u64(190);
+    let __v_21: G = G::from_u64(195);
+    let __v_22: G = G::from_u64(230);
+    let __v_23: G = G::from_u64(2);
+    let __v_24: G = G::from_u64(173);
+    let __v_25: G = G::from_u64(146);
+    let __v_26: G = G::from_u64(20);
+    let __v_27: G = G::from_u64(208);
+    let __v_28: G = G::from_u64(230);
+    let __v_29: G = G::from_u64(55);
+    let __v_30: G = G::from_u64(211);
+    let __v_31: G = G::from_u64(15);
+    let __v_32: G = { let __values: [G; 32] = [__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]; 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_190] = [__v_32];
+    record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_191: usize = 0;
+const IN_191: usize = 0;
+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_191], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = G::from_u64(150);
+    let __v_1: G = G::from_u64(113);
+    let __v_2: G = G::from_u64(253);
+    let __v_3: G = G::from_u64(79);
+    let __v_4: G = G::from_u64(207);
+    let __v_5: G = G::from_u64(188);
+    let __v_6: G = G::from_u64(6);
+    let __v_7: G = G::from_u64(28);
+    let __v_8: G = G::from_u64(147);
+    let __v_9: G = G::from_u64(194);
+    let __v_10: G = G::from_u64(130);
+    let __v_11: G = G::from_u64(72);
+    let __v_12: G = G::from_u64(100);
+    let __v_13: G = G::from_u64(207);
+    let __v_14: G = G::from_u64(3);
+    let __v_15: G = G::from_u64(18);
+    let __v_16: G = G::from_u64(79);
+    let __v_17: G = G::from_u64(254);
+    let __v_18: G = G::from_u64(231);
+    let __v_19: G = G::from_u64(204);
+    let __v_20: G = G::from_u64(34);
+    let __v_21: G = G::from_u64(48);
+    let __v_22: G = G::from_u64(141);
+    let __v_23: G = G::from_u64(225);
+    let __v_24: G = G::from_u64(42);
+    let __v_25: G = G::from_u64(124);
+    let __v_26: G = G::from_u64(130);
+    let __v_27: G = G::from_u64(100);
+    let __v_28: G = G::from_u64(115);
+    let __v_29: G = G::from_u64(228);
+    let __v_30: G = G::from_u64(153);
+    let __v_31: G = G::from_u64(6);
+    let __v_32: G = { let __values: [G; 32] = [__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]; 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_191] = [__v_32];
+    record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_192: usize = 0;
+const IN_192: usize = 0;
+const OUT_192: usize = 1;
+fn aiur_fn_192(
+  inp: [G; IN_192],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_192], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = G::from_u64(26);
+    let __v_1: G = G::from_u64(76);
+    let __v_2: G = G::from_u64(102);
+    let __v_3: G = G::from_u64(247);
+    let __v_4: G = G::from_u64(103);
+    let __v_5: G = G::from_u64(96);
+    let __v_6: G = G::from_u64(245);
+    let __v_7: G = G::from_u64(239);
+    let __v_8: G = G::from_u64(56);
+    let __v_9: G = G::from_u64(109);
+    let __v_10: G = G::from_u64(224);
+    let __v_11: G = G::from_u64(137);
+    let __v_12: G = G::from_u64(104);
+    let __v_13: G = G::from_u64(42);
+    let __v_14: G = G::from_u64(85);
+    let __v_15: G = G::from_u64(183);
+    let __v_16: G = G::from_u64(82);
+    let __v_17: G = G::from_u64(19);
+    let __v_18: G = G::from_u64(30);
+    let __v_19: G = G::from_u64(20);
+    let __v_20: G = G::from_u64(160);
+    let __v_21: G = G::from_u64(133);
+    let __v_22: G = G::from_u64(87);
+    let __v_23: G = G::from_u64(196);
+    let __v_24: G = G::from_u64(70);
+    let __v_25: G = G::from_u64(94);
+    let __v_26: G = G::from_u64(209);
+    let __v_27: G = G::from_u64(127);
+    let __v_28: G = G::from_u64(224);
+    let __v_29: G = G::from_u64(196);
+    let __v_30: G = G::from_u64(220);
+    let __v_31: G = G::from_u64(134);
+    let __v_32: G = { let __values: [G; 32] = [__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]; 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_192] = [__v_32];
+    record.function_queries[192].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_193: usize = 0;
+const IN_193: usize = 0;
+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_193], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = G::from_u64(37);
+    let __v_1: G = G::from_u64(138);
+    let __v_2: G = G::from_u64(115);
+    let __v_3: G = G::from_u64(100);
+    let __v_4: G = G::from_u64(184);
+    let __v_5: G = G::from_u64(124);
+    let __v_6: G = G::from_u64(153);
+    let __v_7: G = G::from_u64(254);
+    let __v_8: G = G::from_u64(159);
+    let __v_9: G = G::from_u64(131);
+    let __v_10: G = G::from_u64(224);
+    let __v_11: G = G::from_u64(94);
+    let __v_12: G = G::from_u64(13);
+    let __v_13: G = G::from_u64(5);
+    let __v_14: G = G::from_u64(201);
+    let __v_15: G = G::from_u64(53);
+    let __v_16: G = G::from_u64(96);
+    let __v_17: G = G::from_u64(154);
+    let __v_18: G = G::from_u64(13);
+    let __v_19: G = G::from_u64(197);
+    let __v_20: G = G::from_u64(223);
+    let __v_21: G = G::from_u64(141);
+    let __v_22: G = G::from_u64(119);
+    let __v_23: G = G::from_u64(147);
+    let __v_24: G = G::from_u64(145);
+    let __v_25: G = G::from_u64(48);
+    let __v_26: G = G::from_u64(239);
+    let __v_27: G = G::from_u64(229);
+    let __v_28: G = G::from_u64(224);
+    let __v_29: G = G::from_u64(239);
+    let __v_30: G = G::from_u64(202);
+    let __v_31: G = G::from_u64(62);
+    let __v_32: G = { let __values: [G; 32] = [__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]; 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_193] = [__v_32];
+    record.function_queries[193].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_194: usize = 0;
+const IN_194: usize = 0;
+const OUT_194: usize = 1;
+fn aiur_fn_194(
+  inp: [G; IN_194],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_194], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = G::from_u64(119);
+    let __v_1: G = G::from_u64(213);
+    let __v_2: G = G::from_u64(25);
+    let __v_3: G = G::from_u64(37);
+    let __v_4: G = G::from_u64(158);
+    let __v_5: G = G::from_u64(201);
+    let __v_6: G = G::from_u64(250);
+    let __v_7: G = G::from_u64(72);
+    let __v_8: G = G::from_u64(157);
+    let __v_9: G = G::from_u64(190);
+    let __v_10: G = G::from_u64(14);
+    let __v_11: G = G::from_u64(61);
+    let __v_12: G = G::from_u64(192);
+    let __v_13: G = G::from_u64(185);
+    let __v_14: G = G::from_u64(53);
+    let __v_15: G = G::from_u64(42);
+    let __v_16: G = G::from_u64(239);
+    let __v_17: G = G::from_u64(52);
+    let __v_18: G = G::from_u64(156);
+    let __v_19: G = G::from_u64(205);
+    let __v_20: G = G::from_u64(170);
+    let __v_21: G = G::from_u64(115);
+    let __v_22: G = G::from_u64(234);
+    let __v_23: G = G::from_u64(88);
+    let __v_24: G = G::from_u64(176);
+    let __v_25: G = G::from_u64(139);
+    let __v_26: G = G::from_u64(176);
+    let __v_27: G = G::from_u64(188);
+    let __v_28: G = G::from_u64(104);
+    let __v_29: G = G::from_u64(53);
+    let __v_30: G = G::from_u64(2);
+    let __v_31: G = G::from_u64(160);
+    let __v_32: G = { let __values: [G; 32] = [__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]; 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_194] = [__v_32];
+    record.function_queries[194].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_195: usize = 0;
+const IN_195: usize = 0;
+const OUT_195: usize = 1;
+fn aiur_fn_195(
+  inp: [G; IN_195],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_195], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = G::from_u64(41);
+    let __v_1: G = G::from_u64(221);
+    let __v_2: G = G::from_u64(45);
+    let __v_3: G = G::from_u64(25);
+    let __v_4: G = G::from_u64(134);
+    let __v_5: G = G::from_u64(165);
+    let __v_6: G = G::from_u64(37);
+    let __v_7: G = G::from_u64(189);
+    let __v_8: G = G::from_u64(222);
+    let __v_9: G = G::from_u64(73);
+    let __v_10: G = G::from_u64(180);
+    let __v_11: G = G::from_u64(173);
+    let __v_12: G = G::from_u64(45);
+    let __v_13: G = G::from_u64(239);
+    let __v_14: G = G::from_u64(195);
+    let __v_15: G = G::from_u64(73);
+    let __v_16: G = G::from_u64(206);
+    let __v_17: G = G::from_u64(199);
+    let __v_18: G = G::from_u64(29);
+    let __v_19: G = G::from_u64(4);
+    let __v_20: G = G::from_u64(132);
+    let __v_21: G = G::from_u64(205);
+    let __v_22: G = G::from_u64(19);
+    let __v_23: G = G::from_u64(242);
+    let __v_24: G = G::from_u64(218);
+    let __v_25: G = G::from_u64(146);
+    let __v_26: G = G::from_u64(241);
+    let __v_27: G = G::from_u64(252);
+    let __v_28: G = G::from_u64(232);
+    let __v_29: G = G::from_u64(154);
+    let __v_30: G = G::from_u64(76);
+    let __v_31: G = G::from_u64(121);
+    let __v_32: G = { let __values: [G; 32] = [__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]; 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_195] = [__v_32];
+    record.function_queries[195].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_196: usize = 0;
+const IN_196: usize = 0;
+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_196], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(233);
     let __v_1: G = G::from_u64(92);
@@ -27302,21 +18647,21 @@ fn aiur_fn_291(
     let __v_30: G = G::from_u64(146);
     let __v_31: G = G::from_u64(6);
     let __v_32: G = { let __values: [G; 32] = [__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]; 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_291] = [__v_32];
-    record.function_queries[291].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_196] = [__v_32];
+    record.function_queries[196].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_292: usize = 0;
-const IN_292: usize = 0;
-const OUT_292: usize = 1;
-fn aiur_fn_292(
-  inp: [G; IN_292],
+const INPUT_SIZE_197: usize = 0;
+const IN_197: usize = 0;
+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_292], ExecError> {
+) -> Result<[G; OUT_197], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(107);
     let __v_1: G = G::from_u64(182);
@@ -27351,21 +18696,21 @@ fn aiur_fn_292(
     let __v_30: G = G::from_u64(109);
     let __v_31: G = G::from_u64(172);
     let __v_32: G = { let __values: [G; 32] = [__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]; 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_292] = [__v_32];
-    record.function_queries[292].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_197] = [__v_32];
+    record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_293: usize = 0;
-const IN_293: usize = 0;
-const OUT_293: usize = 1;
-fn aiur_fn_293(
-  inp: [G; IN_293],
+const INPUT_SIZE_198: usize = 0;
+const IN_198: usize = 0;
+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_293], ExecError> {
+) -> Result<[G; OUT_198], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(237);
     let __v_1: G = G::from_u64(67);
@@ -27400,21 +18745,21 @@ fn aiur_fn_293(
     let __v_30: G = G::from_u64(173);
     let __v_31: G = G::from_u64(177);
     let __v_32: G = { let __values: [G; 32] = [__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]; 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_293] = [__v_32];
-    record.function_queries[293].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_198] = [__v_32];
+    record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_294: usize = 0;
-const IN_294: usize = 0;
-const OUT_294: usize = 1;
-fn aiur_fn_294(
-  inp: [G; IN_294],
+const INPUT_SIZE_199: usize = 0;
+const IN_199: usize = 0;
+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_294], ExecError> {
+) -> Result<[G; OUT_199], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(124);
     let __v_1: G = G::from_u64(251);
@@ -27429,237 +18774,41 @@ fn aiur_fn_294(
     let __v_10: G = G::from_u64(6);
     let __v_11: G = G::from_u64(97);
     let __v_12: G = G::from_u64(16);
-    let __v_13: G = G::from_u64(186);
-    let __v_14: G = G::from_u64(1);
-    let __v_15: G = G::from_u64(169);
-    let __v_16: G = G::from_u64(127);
-    let __v_17: G = G::from_u64(181);
-    let __v_18: G = G::from_u64(151);
-    let __v_19: G = G::from_u64(218);
-    let __v_20: G = G::from_u64(242);
-    let __v_21: G = G::from_u64(159);
-    let __v_22: G = G::from_u64(92);
-    let __v_23: G = G::from_u64(7);
-    let __v_24: G = G::from_u64(247);
-    let __v_25: G = G::from_u64(35);
-    let __v_26: G = G::from_u64(102);
-    let __v_27: G = G::from_u64(7);
-    let __v_28: G = G::from_u64(47);
-    let __v_29: G = G::from_u64(37);
-    let __v_30: G = G::from_u64(7);
-    let __v_31: G = G::from_u64(68);
-    let __v_32: G = { let __values: [G; 32] = [__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]; 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_294] = [__v_32];
-    record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_295: usize = 0;
-const IN_295: usize = 0;
-const OUT_295: usize = 1;
-fn aiur_fn_295(
-  inp: [G; IN_295],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_295], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(26);
-    let __v_1: G = G::from_u64(76);
-    let __v_2: G = G::from_u64(102);
-    let __v_3: G = G::from_u64(247);
-    let __v_4: G = G::from_u64(103);
-    let __v_5: G = G::from_u64(96);
-    let __v_6: G = G::from_u64(245);
-    let __v_7: G = G::from_u64(239);
-    let __v_8: G = G::from_u64(56);
-    let __v_9: G = G::from_u64(109);
-    let __v_10: G = G::from_u64(224);
-    let __v_11: G = G::from_u64(137);
-    let __v_12: G = G::from_u64(104);
-    let __v_13: G = G::from_u64(42);
-    let __v_14: G = G::from_u64(85);
-    let __v_15: G = G::from_u64(183);
-    let __v_16: G = G::from_u64(82);
-    let __v_17: G = G::from_u64(19);
-    let __v_18: G = G::from_u64(30);
-    let __v_19: G = G::from_u64(20);
-    let __v_20: G = G::from_u64(160);
-    let __v_21: G = G::from_u64(133);
-    let __v_22: G = G::from_u64(87);
-    let __v_23: G = G::from_u64(196);
-    let __v_24: G = G::from_u64(70);
-    let __v_25: G = G::from_u64(94);
-    let __v_26: G = G::from_u64(209);
-    let __v_27: G = G::from_u64(127);
-    let __v_28: G = G::from_u64(224);
-    let __v_29: G = G::from_u64(196);
-    let __v_30: G = G::from_u64(220);
-    let __v_31: G = G::from_u64(134);
-    let __v_32: G = { let __values: [G; 32] = [__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]; 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_295] = [__v_32];
-    record.function_queries[295].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_296: usize = 0;
-const IN_296: usize = 0;
-const OUT_296: usize = 1;
-fn aiur_fn_296(
-  inp: [G; IN_296],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_296], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(41);
-    let __v_1: G = G::from_u64(221);
-    let __v_2: G = G::from_u64(45);
-    let __v_3: G = G::from_u64(25);
-    let __v_4: G = G::from_u64(134);
-    let __v_5: G = G::from_u64(165);
-    let __v_6: G = G::from_u64(37);
-    let __v_7: G = G::from_u64(189);
-    let __v_8: G = G::from_u64(222);
-    let __v_9: G = G::from_u64(73);
-    let __v_10: G = G::from_u64(180);
-    let __v_11: G = G::from_u64(173);
-    let __v_12: G = G::from_u64(45);
-    let __v_13: G = G::from_u64(239);
-    let __v_14: G = G::from_u64(195);
-    let __v_15: G = G::from_u64(73);
-    let __v_16: G = G::from_u64(206);
-    let __v_17: G = G::from_u64(199);
-    let __v_18: G = G::from_u64(29);
-    let __v_19: G = G::from_u64(4);
-    let __v_20: G = G::from_u64(132);
-    let __v_21: G = G::from_u64(205);
-    let __v_22: G = G::from_u64(19);
-    let __v_23: G = G::from_u64(242);
-    let __v_24: G = G::from_u64(218);
-    let __v_25: G = G::from_u64(146);
-    let __v_26: G = G::from_u64(241);
-    let __v_27: G = G::from_u64(252);
-    let __v_28: G = G::from_u64(232);
-    let __v_29: G = G::from_u64(154);
-    let __v_30: G = G::from_u64(76);
-    let __v_31: G = G::from_u64(121);
-    let __v_32: G = { let __values: [G; 32] = [__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]; 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_296] = [__v_32];
-    record.function_queries[296].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_297: usize = 0;
-const IN_297: usize = 0;
-const OUT_297: usize = 1;
-fn aiur_fn_297(
-  inp: [G; IN_297],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_297], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(150);
-    let __v_1: G = G::from_u64(113);
-    let __v_2: G = G::from_u64(253);
-    let __v_3: G = G::from_u64(79);
-    let __v_4: G = G::from_u64(207);
-    let __v_5: G = G::from_u64(188);
-    let __v_6: G = G::from_u64(6);
-    let __v_7: G = G::from_u64(28);
-    let __v_8: G = G::from_u64(147);
-    let __v_9: G = G::from_u64(194);
-    let __v_10: G = G::from_u64(130);
-    let __v_11: G = G::from_u64(72);
-    let __v_12: G = G::from_u64(100);
-    let __v_13: G = G::from_u64(207);
-    let __v_14: G = G::from_u64(3);
-    let __v_15: G = G::from_u64(18);
-    let __v_16: G = G::from_u64(79);
-    let __v_17: G = G::from_u64(254);
-    let __v_18: G = G::from_u64(231);
-    let __v_19: G = G::from_u64(204);
-    let __v_20: G = G::from_u64(34);
-    let __v_21: G = G::from_u64(48);
-    let __v_22: G = G::from_u64(141);
-    let __v_23: G = G::from_u64(225);
-    let __v_24: G = G::from_u64(42);
-    let __v_25: G = G::from_u64(124);
-    let __v_26: G = G::from_u64(130);
-    let __v_27: G = G::from_u64(100);
-    let __v_28: G = G::from_u64(115);
-    let __v_29: G = G::from_u64(228);
-    let __v_30: G = G::from_u64(153);
-    let __v_31: G = G::from_u64(6);
-    let __v_32: G = { let __values: [G; 32] = [__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]; 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_297] = [__v_32];
-    record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_298: usize = 0;
-const IN_298: usize = 0;
-const OUT_298: usize = 1;
-fn aiur_fn_298(
-  inp: [G; IN_298],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_298], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(89);
-    let __v_1: G = G::from_u64(79);
-    let __v_2: G = G::from_u64(177);
-    let __v_3: G = G::from_u64(238);
-    let __v_4: G = G::from_u64(222);
-    let __v_5: G = G::from_u64(199);
-    let __v_6: G = G::from_u64(201);
-    let __v_7: G = G::from_u64(57);
-    let __v_8: G = G::from_u64(204);
-    let __v_9: G = G::from_u64(135);
-    let __v_10: G = G::from_u64(43);
-    let __v_11: G = G::from_u64(108);
-    let __v_12: G = G::from_u64(4);
-    let __v_13: G = G::from_u64(204);
-    let __v_14: G = G::from_u64(59);
-    let __v_15: G = G::from_u64(62);
-    let __v_16: G = G::from_u64(10);
-    let __v_17: G = G::from_u64(151);
-    let __v_18: G = G::from_u64(100);
-    let __v_19: G = G::from_u64(250);
-    let __v_20: G = G::from_u64(190);
-    let __v_21: G = G::from_u64(195);
-    let __v_22: G = G::from_u64(230);
-    let __v_23: G = G::from_u64(2);
-    let __v_24: G = G::from_u64(173);
-    let __v_25: G = G::from_u64(146);
-    let __v_26: G = G::from_u64(20);
-    let __v_27: G = G::from_u64(208);
-    let __v_28: G = G::from_u64(230);
-    let __v_29: G = G::from_u64(55);
-    let __v_30: G = G::from_u64(211);
-    let __v_31: G = G::from_u64(15);
+    let __v_13: G = G::from_u64(186);
+    let __v_14: G = G::from_u64(1);
+    let __v_15: G = G::from_u64(169);
+    let __v_16: G = G::from_u64(127);
+    let __v_17: G = G::from_u64(181);
+    let __v_18: G = G::from_u64(151);
+    let __v_19: G = G::from_u64(218);
+    let __v_20: G = G::from_u64(242);
+    let __v_21: G = G::from_u64(159);
+    let __v_22: G = G::from_u64(92);
+    let __v_23: G = G::from_u64(7);
+    let __v_24: G = G::from_u64(247);
+    let __v_25: G = G::from_u64(35);
+    let __v_26: G = G::from_u64(102);
+    let __v_27: G = G::from_u64(7);
+    let __v_28: G = G::from_u64(47);
+    let __v_29: G = G::from_u64(37);
+    let __v_30: G = G::from_u64(7);
+    let __v_31: G = G::from_u64(68);
     let __v_32: G = { let __values: [G; 32] = [__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]; 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_298] = [__v_32];
-    record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_199] = [__v_32];
+    record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_299: usize = 0;
-const IN_299: usize = 0;
-const OUT_299: usize = 1;
-fn aiur_fn_299(
-  inp: [G; IN_299],
+const INPUT_SIZE_200: usize = 0;
+const IN_200: usize = 0;
+const OUT_200: usize = 1;
+fn aiur_fn_200(
+  inp: [G; IN_200],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_299], ExecError> {
+) -> Result<[G; OUT_200], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(130);
     let __v_1: G = G::from_u64(229);
@@ -27694,691 +18843,1650 @@ fn aiur_fn_299(
     let __v_30: G = G::from_u64(147);
     let __v_31: G = G::from_u64(148);
     let __v_32: G = { let __values: [G; 32] = [__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]; 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_299] = [__v_32];
-    record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_200] = [__v_32];
+    record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_300: usize = 0;
-const IN_300: usize = 0;
-const OUT_300: usize = 1;
-fn aiur_fn_300(
-  inp: [G; IN_300],
+const INPUT_SIZE_201: usize = 0;
+const IN_201: usize = 0;
+const OUT_201: usize = 1;
+fn aiur_fn_201(
+  inp: [G; IN_201],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_300], ExecError> {
+) -> Result<[G; OUT_201], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(37);
-    let __v_1: G = G::from_u64(138);
-    let __v_2: G = G::from_u64(115);
-    let __v_3: G = G::from_u64(100);
-    let __v_4: G = G::from_u64(184);
-    let __v_5: G = G::from_u64(124);
-    let __v_6: G = G::from_u64(153);
-    let __v_7: G = G::from_u64(254);
-    let __v_8: G = G::from_u64(159);
-    let __v_9: G = G::from_u64(131);
-    let __v_10: G = G::from_u64(224);
-    let __v_11: G = G::from_u64(94);
-    let __v_12: G = G::from_u64(13);
-    let __v_13: G = G::from_u64(5);
-    let __v_14: G = G::from_u64(201);
-    let __v_15: G = G::from_u64(53);
-    let __v_16: G = G::from_u64(96);
-    let __v_17: G = G::from_u64(154);
-    let __v_18: G = G::from_u64(13);
-    let __v_19: G = G::from_u64(197);
-    let __v_20: G = G::from_u64(223);
-    let __v_21: G = G::from_u64(141);
-    let __v_22: G = G::from_u64(119);
-    let __v_23: G = G::from_u64(147);
-    let __v_24: G = G::from_u64(145);
-    let __v_25: G = G::from_u64(48);
-    let __v_26: G = G::from_u64(239);
-    let __v_27: G = G::from_u64(229);
-    let __v_28: G = G::from_u64(224);
-    let __v_29: G = G::from_u64(239);
-    let __v_30: G = G::from_u64(202);
-    let __v_31: G = G::from_u64(62);
+    let __v_0: G = G::from_u64(122);
+    let __v_1: G = G::from_u64(178);
+    let __v_2: G = G::from_u64(213);
+    let __v_3: G = G::from_u64(42);
+    let __v_4: G = G::from_u64(197);
+    let __v_5: G = G::from_u64(47);
+    let __v_6: G = G::from_u64(209);
+    let __v_7: G = G::from_u64(245);
+    let __v_8: G = G::from_u64(24);
+    let __v_9: G = G::from_u64(9);
+    let __v_10: G = G::from_u64(183);
+    let __v_11: G = G::from_u64(24);
+    let __v_12: G = G::from_u64(229);
+    let __v_13: G = G::from_u64(60);
+    let __v_14: G = G::from_u64(208);
+    let __v_15: G = G::from_u64(88);
+    let __v_16: G = G::from_u64(172);
+    let __v_17: G = G::from_u64(75);
+    let __v_18: G = G::from_u64(80);
+    let __v_19: G = G::from_u64(214);
+    let __v_20: G = G::from_u64(81);
+    let __v_21: G = G::from_u64(80);
+    let __v_22: G = G::from_u64(231);
+    let __v_23: G = G::from_u64(138);
+    let __v_24: G = G::from_u64(230);
+    let __v_25: G = G::from_u64(25);
+    let __v_26: G = G::from_u64(19);
+    let __v_27: G = G::from_u64(156);
+    let __v_28: G = G::from_u64(207);
+    let __v_29: G = G::from_u64(19);
+    let __v_30: G = G::from_u64(200);
+    let __v_31: G = G::from_u64(253);
     let __v_32: G = { let __values: [G; 32] = [__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]; 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_300] = [__v_32];
-    record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_201] = [__v_32];
+    record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_301: usize = 0;
-const IN_301: usize = 0;
-const OUT_301: usize = 1;
-fn aiur_fn_301(
-  inp: [G; IN_301],
+const INPUT_SIZE_202: usize = 1;
+const IN_202: usize = 1;
+const OUT_202: usize = 1;
+fn aiur_fn_202(
+  inp: [G; IN_202],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_202], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[189].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_189] = unsafe { *(result.output.as_ptr() as *const [G; OUT_189]) }; __ret } else { aiur_fn_189(__args, record, io_buffer, __cu)? } };
+    let __v_1: G = __r_arr[0];
+    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_2: G = __r_arr[0];
+    match __v_2.as_canonical_u64() {
+      1u64 => {
+        let __v_3: G = G::from_u64(1);
+        let __ret: [G; OUT_202] = [__v_3];
+        record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[190].get_mut(&__args[..]) { 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_3: G = __r_arr[0];
+        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_4: G = __r_arr[0];
+        match __v_4.as_canonical_u64() {
+          1u64 => {
+            let __v_5: G = G::from_u64(1);
+            let __ret: [G; OUT_202] = [__v_5];
+            record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[191].get_mut(&__args[..]) { 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_5: G = __r_arr[0];
+            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_6: G = __r_arr[0];
+            match __v_6.as_canonical_u64() {
+              1u64 => {
+                let __v_7: G = G::from_u64(1);
+                let __ret: [G; OUT_202] = [__v_7];
+                record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { 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_7: G = __r_arr[0];
+                let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_8: G = __r_arr[0];
+                match __v_8.as_canonical_u64() {
+                  1u64 => {
+                    let __v_9: G = G::from_u64(1);
+                    let __ret: [G; OUT_202] = [__v_9];
+                    record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
+                  },
+                  _ => {
+                    let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[197].get_mut(&__args[..]) { 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_9: G = __r_arr[0];
+                    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_10: G = __r_arr[0];
+                    match __v_10.as_canonical_u64() {
+                      1u64 => {
+                        let __v_11: G = G::from_u64(1);
+                        let __ret: [G; OUT_202] = [__v_11];
+                        record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        return Ok(__ret);
+                      },
+                      _ => {
+                        let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { 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_11: G = __r_arr[0];
+                        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_12: G = __r_arr[0];
+                        match __v_12.as_canonical_u64() {
+                          1u64 => {
+                            let __v_13: G = G::from_u64(1);
+                            let __ret: [G; OUT_202] = [__v_13];
+                            record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            return Ok(__ret);
+                          },
+                          _ => {
+                            let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { 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_13: G = __r_arr[0];
+                            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_14: G = __r_arr[0];
+                            match __v_14.as_canonical_u64() {
+                              1u64 => {
+                                let __v_15: G = G::from_u64(1);
+                                let __ret: [G; OUT_202] = [__v_15];
+                                record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                return Ok(__ret);
+                              },
+                              _ => {
+                                let __v_15: G = G::from_u64(0);
+                                let __ret: [G; OUT_202] = [__v_15];
+                                record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                return Ok(__ret);
+                              },
+                            }
+                          },
+                        }
+                      },
+                    }
+                  },
+                }
+              },
+            }
+          },
+        }
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_203: usize = 3;
+const IN_203: usize = 3;
+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_203], 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_711] = { let __args: [G; IN_711] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } else { aiur_fn_711(__args, record, io_buffer, __cu)? } };
+    let __v_3: G = __r_arr[0];
+    let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[191].get_mut(&__args[..]) { 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_4: G = __r_arr[0];
+    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_5: G = __r_arr[0];
+    match __v_5.as_canonical_u64() {
+      1u64 => {
+        match __v_3.as_canonical_u64() {
+          1u64 => {
+            let __v_6: G = G::from_u64(0);
+            let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } };
+            let __v_7: G = __r_arr[0];
+            let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_7, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { 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_8: G = __r_arr[0];
+            let __v_9: G = __r_arr[1];
+            match __v_8.as_canonical_u64() {
+              1u64 => {
+                let __v_10: G = G::from_u64(1);
+                let __v_11: G = G::from_u64(7);
+                let __v_12: G = G::from_u64(1);
+                let __v_13: G = G::from_u64(0);
+                let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_9, __v_13]; 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_203] = [__v_10, __v_14];
+                record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              0u64 => {
+                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 = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; 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_203] = [__v_10, __v_14];
+                record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64()));
+              },
+            }
+          },
+          _ => {
+            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 = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_9]; 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_203] = [__v_6, __v_10];
+            record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+        }
+      },
+      _ => {
+        let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[189].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_189] = unsafe { *(result.output.as_ptr() as *const [G; OUT_189]) }; __ret } else { aiur_fn_189(__args, record, io_buffer, __cu)? } };
+        let __v_6: G = __r_arr[0];
+        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_7: G = __r_arr[0];
+        match __v_7.as_canonical_u64() {
+          1u64 => {
+            let __v_8: G = G::from_u64(1);
+            let __v_9: G = { let __a_val = __v_3.as_canonical_u64(); let __b_val = __v_8.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_9.as_canonical_u64() {
+              1u64 => {
+                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 = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; 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_203] = [__v_10, __v_14];
+                record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                let __v_10: G = G::from_u64(0);
+                let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } };
+                let __v_11: 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_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).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_12: G = __loaded[0];
+                let __v_13: G = __loaded[1];
+                let __v_14: G = __loaded[2];
+                let __v_15: G = __loaded[3];
+                match __v_12.as_canonical_u64() {
+                  7u64 => {
+                    match __v_13.as_canonical_u64() {
+                      1u64 => {
+                        let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } else { aiur_fn_711(__args, record, io_buffer, __cu)? } };
+                        let __v_16: G = __r_arr[0];
+                        let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[216].get_mut(&__args[..]) { 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_17: G = __r_arr[0];
+                        let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { 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_18: G = __r_arr[0];
+                        let __v_19: G = G::from_u64(1);
+                        let __v_20: G = G::from_u64(7);
+                        let __v_21: G = G::from_u64(0);
+                        let __v_22: G = G::from_u64(0);
+                        let __v_23: G = { let __values: [G; 4] = [__v_20, __v_21, __v_18, __v_22]; 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_203] = [__v_19, __v_23];
+                        record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        return Ok(__ret);
+                      },
+                      _ => {
+                        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 = { let __values: [G; 4] = [__v_17, __v_18, __v_19, __v_19]; 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_203] = [__v_16, __v_20];
+                        record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        return Ok(__ret);
+                      },
+                    }
+                  },
+                  _ => {
+                    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 = { let __values: [G; 4] = [__v_17, __v_18, __v_19, __v_19]; 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_203] = [__v_16, __v_20];
+                    record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
+                  },
+                }
+              },
+            }
+          },
+          _ => {
+            let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { 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_8: G = __r_arr[0];
+            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_9: G = __r_arr[0];
+            match __v_9.as_canonical_u64() {
+              1u64 => {
+                let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { 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_10: G = __r_arr[0];
+                let __v_11: G = __r_arr[1];
+                let __ret: [G; OUT_203] = [__v_10, __v_11];
+                record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[197].get_mut(&__args[..]) { 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_10: G = __r_arr[0];
+                let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_11: G = __r_arr[0];
+                match __v_11.as_canonical_u64() {
+                  1u64 => {
+                    let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { 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_12: G = __r_arr[0];
+                    let __v_13: G = __r_arr[1];
+                    let __ret: [G; OUT_203] = [__v_12, __v_13];
+                    record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
+                  },
+                  _ => {
+                    let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { 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_12: G = __r_arr[0];
+                    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_13: G = __r_arr[0];
+                    match __v_13.as_canonical_u64() {
+                      1u64 => {
+                        let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { 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 __v_15: G = __r_arr[1];
+                        let __ret: [G; OUT_203] = [__v_14, __v_15];
+                        record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        return Ok(__ret);
+                      },
+                      _ => {
+                        let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { 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_14: G = __r_arr[0];
+                        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_15: G = __r_arr[0];
+                        match __v_15.as_canonical_u64() {
+                          1u64 => {
+                            let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[472].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_472] = unsafe { *(result.output.as_ptr() as *const [G; OUT_472]) }; __ret } else { aiur_fn_472(__args, record, io_buffer, __cu)? } };
+                            let __v_16: G = __r_arr[0];
+                            let __v_17: G = __r_arr[1];
+                            let __ret: [G; OUT_203] = [__v_16, __v_17];
+                            record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            return Ok(__ret);
+                          },
+                          _ => {
+                            let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[190].get_mut(&__args[..]) { 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_16: G = __r_arr[0];
+                            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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];
+                            match __v_17.as_canonical_u64() {
+                              1u64 => {
+                                let __v_18: G = G::from_u64(2);
+                                let __v_19: G = { let __a_val = __v_3.as_canonical_u64(); let __b_val = __v_18.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_19.as_canonical_u64() {
+                                  1u64 => {
+                                    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 __v_24: G = { let __values: [G; 4] = [__v_21, __v_22, __v_23, __v_23]; 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_203] = [__v_20, __v_24];
+                                    record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                    return Ok(__ret);
+                                  },
+                                  _ => {
+                                    let __v_20: G = G::from_u64(0);
+                                    let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_1, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } };
+                                    let __v_21: G = __r_arr[0];
+                                    let __v_22: G = G::from_u64(1);
+                                    let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_1, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } };
+                                    let __v_23: 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_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: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+                                    let __v_24: G = __loaded[0];
+                                    let __v_25: G = __loaded[1];
+                                    let __v_26: G = __loaded[2];
+                                    let __v_27: G = __loaded[3];
+                                    match __v_24.as_canonical_u64() {
+                                      7u64 => {
+                                        match __v_25.as_canonical_u64() {
+                                          1u64 => {
+                                            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_23.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).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_28: G = __loaded[0];
+                                            let __v_29: G = __loaded[1];
+                                            let __v_30: G = __loaded[2];
+                                            let __v_31: G = __loaded[3];
+                                            match __v_28.as_canonical_u64() {
+                                              7u64 => {
+                                                match __v_29.as_canonical_u64() {
+                                                  1u64 => {
+                                                    let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_26, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[710].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_710] = unsafe { *(result.output.as_ptr() as *const [G; OUT_710]) }; __ret } else { aiur_fn_710(__args, record, io_buffer, __cu)? } };
+                                                    let __v_32: G = __r_arr[0];
+                                                    let __v_33: G = G::from_u64(1);
+                                                    let __v_34: G = G::from_u64(7);
+                                                    let __v_35: G = G::from_u64(1);
+                                                    let __v_36: G = G::from_u64(0);
+                                                    let __v_37: G = { let __values: [G; 4] = [__v_34, __v_35, __v_32, __v_36]; 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_203] = [__v_33, __v_37];
+                                                    record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                    return Ok(__ret);
+                                                  },
+                                                  _ => {
+                                                    let __v_32: G = G::from_u64(0);
+                                                    let __v_33: G = G::from_u64(0);
+                                                    let __v_34: G = G::from_u64(0);
+                                                    let __v_35: G = G::from_u64(0);
+                                                    let __v_36: G = { let __values: [G; 4] = [__v_33, __v_34, __v_35, __v_35]; 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_203] = [__v_32, __v_36];
+                                                    record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                    return Ok(__ret);
+                                                  },
+                                                }
+                                              },
+                                              _ => {
+                                                let __v_32: G = G::from_u64(0);
+                                                let __v_33: G = G::from_u64(0);
+                                                let __v_34: G = G::from_u64(0);
+                                                let __v_35: G = G::from_u64(0);
+                                                let __v_36: G = { let __values: [G; 4] = [__v_33, __v_34, __v_35, __v_35]; 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_203] = [__v_32, __v_36];
+                                                record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                return Ok(__ret);
+                                              },
+                                            }
+                                          },
+                                          _ => {
+                                            let __v_28: G = G::from_u64(0);
+                                            let __v_29: G = G::from_u64(0);
+                                            let __v_30: G = G::from_u64(0);
+                                            let __v_31: G = G::from_u64(0);
+                                            let __v_32: G = { let __values: [G; 4] = [__v_29, __v_30, __v_31, __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 __ret: [G; OUT_203] = [__v_28, __v_32];
+                                            record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                            return Ok(__ret);
+                                          },
+                                        }
+                                      },
+                                      _ => {
+                                        let __v_28: G = G::from_u64(0);
+                                        let __v_29: G = G::from_u64(0);
+                                        let __v_30: G = G::from_u64(0);
+                                        let __v_31: G = G::from_u64(0);
+                                        let __v_32: G = { let __values: [G; 4] = [__v_29, __v_30, __v_31, __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 __ret: [G; OUT_203] = [__v_28, __v_32];
+                                        record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                        return Ok(__ret);
+                                      },
+                                    }
+                                  },
+                                }
+                              },
+                              _ => {
+                                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 = { let __values: [G; 4] = [__v_19, __v_20, __v_21, __v_21]; 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_203] = [__v_18, __v_22];
+                                record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                return Ok(__ret);
+                              },
+                            }
+                          },
+                        }
+                      },
+                    }
+                  },
+                }
+              },
+            }
+          },
+        }
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_204: usize = 1;
+const IN_204: usize = 1;
+const OUT_204: usize = 2;
+fn aiur_fn_204(
+  inp: [G; IN_204],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_204], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } else { aiur_fn_711(__args, record, io_buffer, __cu)? } };
+    let __v_1: G = __r_arr[0];
+    let __v_2: G = G::from_u64(1);
+    let __v_3: G = { let __a_val = __v_1.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_3.as_canonical_u64() {
+      1u64 => {
+        let __v_4: G = G::from_u64(0);
+        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 = { let __values: [G; 4] = [__v_5, __v_6, __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_204] = [__v_4, __v_8];
+        record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __v_4: G = G::from_u64(0);
+        let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } };
+        let __v_5: 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_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: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].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];
+        match __v_6.as_canonical_u64() {
+          7u64 => {
+            match __v_7.as_canonical_u64() {
+              1u64 => {
+                let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { 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_10: G = __r_arr[0];
+                let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[216].get_mut(&__args[..]) { 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_11: G = __r_arr[0];
+                let __v_12: G = G::from_u64(7);
+                let __v_13: G = G::from_u64(0);
+                let __v_14: G = G::from_u64(0);
+                let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_11, __v_14]; 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_16: G = G::from_u64(2);
+                let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { 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 = G::from_u64(1);
+                let __v_19: G = G::from_u64(1);
+                let __v_20: G = { let __values: [G; 3] = [__v_18, __v_19, __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 = G::from_u64(0);
+                let __v_22: G = { let __values: [G; 4] = [__v_16, __v_17, __v_20, __v_21]; 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_23: G = G::from_u64(1);
+                let __v_24: G = G::from_u64(3);
+                let __v_25: G = G::from_u64(0);
+                let __v_26: G = { let __values: [G; 4] = [__v_24, __v_22, __v_15, __v_25]; 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_204] = [__v_23, __v_26];
+                record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                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 = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; 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_204] = [__v_10, __v_14];
+                record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+            }
+          },
+          _ => {
+            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 = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; 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_204] = [__v_10, __v_14];
+            record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+        }
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_205: usize = 1;
+const IN_205: usize = 1;
+const OUT_205: usize = 2;
+fn aiur_fn_205(
+  inp: [G; IN_205],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_205], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } else { aiur_fn_711(__args, record, io_buffer, __cu)? } };
+    let __v_1: G = __r_arr[0];
+    let __v_2: G = G::from_u64(1);
+    let __v_3: G = { let __a_val = __v_1.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_3.as_canonical_u64() {
+      1u64 => {
+        let __v_4: G = G::from_u64(0);
+        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 = { let __values: [G; 4] = [__v_5, __v_6, __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_205] = [__v_4, __v_8];
+        record.function_queries[205].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __v_4: G = G::from_u64(0);
+        let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } };
+        let __v_5: 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_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: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].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];
+        match __v_6.as_canonical_u64() {
+          7u64 => {
+            match __v_7.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_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).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() {
+                  1u64 => {
+                    let __v_13: G = G::from_u64(1);
+                    let __v_14: G = G::from_u64(2);
+                    let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { 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_15: G = __r_arr[0];
+                    let __v_16: G = G::from_u64(1);
+                    let __v_17: G = G::from_u64(1);
+                    let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __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 = G::from_u64(0);
+                    let __v_20: G = { let __values: [G; 4] = [__v_14, __v_15, __v_18, __v_19]; 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_205] = [__v_13, __v_20];
+                    record.function_queries[205].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
+                  },
+                  _ => {
+                    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; 4] = [__v_14, __v_15, __v_16, __v_16]; 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_205] = [__v_13, __v_17];
+                    record.function_queries[205].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
+                  },
+                }
+              },
+              _ => {
+                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 = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; 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_205] = [__v_10, __v_14];
+                record.function_queries[205].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+            }
+          },
+          _ => {
+            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 = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; 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_205] = [__v_10, __v_14];
+            record.function_queries[205].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+        }
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_206: usize = 1;
+const IN_206: usize = 1;
+const OUT_206: usize = 0;
+fn aiur_fn_206(
+  inp: [G; IN_206],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_301], ExecError> {
+) -> Result<[G; OUT_206], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(119);
-    let __v_1: G = G::from_u64(213);
-    let __v_2: G = G::from_u64(25);
-    let __v_3: G = G::from_u64(37);
-    let __v_4: G = G::from_u64(158);
-    let __v_5: G = G::from_u64(201);
-    let __v_6: G = G::from_u64(250);
-    let __v_7: G = G::from_u64(72);
-    let __v_8: G = G::from_u64(157);
-    let __v_9: G = G::from_u64(190);
-    let __v_10: G = G::from_u64(14);
-    let __v_11: G = G::from_u64(61);
-    let __v_12: G = G::from_u64(192);
-    let __v_13: G = G::from_u64(185);
-    let __v_14: G = G::from_u64(53);
-    let __v_15: G = G::from_u64(42);
-    let __v_16: G = G::from_u64(239);
-    let __v_17: G = G::from_u64(52);
-    let __v_18: G = G::from_u64(156);
-    let __v_19: G = G::from_u64(205);
-    let __v_20: G = G::from_u64(170);
-    let __v_21: G = G::from_u64(115);
-    let __v_22: G = G::from_u64(234);
-    let __v_23: G = G::from_u64(88);
-    let __v_24: G = G::from_u64(176);
-    let __v_25: G = G::from_u64(139);
-    let __v_26: G = G::from_u64(176);
-    let __v_27: G = G::from_u64(188);
-    let __v_28: G = G::from_u64(104);
-    let __v_29: G = G::from_u64(53);
-    let __v_30: G = G::from_u64(2);
-    let __v_31: G = G::from_u64(160);
-    let __v_32: G = { let __values: [G; 32] = [__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]; 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_301] = [__v_32];
-    record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
+    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 __ret: [G; OUT_206] = [];
+        record.function_queries[206].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[210].get_mut(&__args[..]) { 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_4: G = __r_arr[0];
+        let __v_5: G = __r_arr[1];
+        let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { 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 __ret: [G; OUT_206] = [];
+        record.function_queries[206].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+      },
+    }
   })
 }
 
-const INPUT_SIZE_302: usize = 0;
-const IN_302: usize = 0;
-const OUT_302: usize = 1;
-fn aiur_fn_302(
-  inp: [G; IN_302],
+const INPUT_SIZE_207: usize = 1;
+const IN_207: usize = 1;
+const OUT_207: usize = 1;
+fn aiur_fn_207(
+  inp: [G; IN_207],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_302], ExecError> {
+) -> Result<[G; OUT_207], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(162);
-    let __v_1: G = G::from_u64(154);
-    let __v_2: G = G::from_u64(99);
-    let __v_3: G = G::from_u64(97);
-    let __v_4: G = G::from_u64(118);
-    let __v_5: G = G::from_u64(207);
-    let __v_6: G = G::from_u64(17);
-    let __v_7: G = G::from_u64(53);
-    let __v_8: G = G::from_u64(208);
-    let __v_9: G = G::from_u64(119);
-    let __v_10: G = G::from_u64(235);
-    let __v_11: G = G::from_u64(7);
-    let __v_12: G = G::from_u64(71);
-    let __v_13: G = G::from_u64(152);
-    let __v_14: G = G::from_u64(249);
-    let __v_15: G = G::from_u64(0);
-    let __v_16: G = G::from_u64(124);
-    let __v_17: G = G::from_u64(120);
-    let __v_18: G = G::from_u64(231);
-    let __v_19: G = G::from_u64(128);
-    let __v_20: G = G::from_u64(19);
-    let __v_21: G = G::from_u64(131);
-    let __v_22: G = G::from_u64(233);
-    let __v_23: G = G::from_u64(207);
-    let __v_24: G = G::from_u64(243);
-    let __v_25: G = G::from_u64(99);
-    let __v_26: G = G::from_u64(186);
-    let __v_27: G = G::from_u64(229);
-    let __v_28: G = G::from_u64(237);
-    let __v_29: G = G::from_u64(240);
-    let __v_30: G = G::from_u64(87);
-    let __v_31: G = G::from_u64(98);
-    let __v_32: G = { let __values: [G; 32] = [__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]; 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_302] = [__v_32];
-    record.function_queries[302].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __v_0: G = inp[0];
+    let __v_1: G = G::from_u64(65);
+    let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { 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_2: G = __r_arr[0];
+    let __ret: [G; OUT_207] = [__v_2];
+    record.function_queries[207].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_303: usize = 0;
-const IN_303: usize = 0;
-const OUT_303: usize = 1;
-fn aiur_fn_303(
-  inp: [G; IN_303],
+const INPUT_SIZE_208: usize = 2;
+const IN_208: usize = 2;
+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_303], ExecError> {
+) -> Result<[G; OUT_208], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(221);
-    let __v_1: G = G::from_u64(161);
-    let __v_2: G = G::from_u64(43);
-    let __v_3: G = G::from_u64(203);
-    let __v_4: G = G::from_u64(51);
-    let __v_5: G = G::from_u64(7);
-    let __v_6: G = G::from_u64(39);
-    let __v_7: G = G::from_u64(246);
-    let __v_8: G = G::from_u64(223);
-    let __v_9: G = G::from_u64(184);
-    let __v_10: G = G::from_u64(22);
-    let __v_11: G = G::from_u64(188);
-    let __v_12: G = G::from_u64(151);
-    let __v_13: G = G::from_u64(82);
-    let __v_14: G = G::from_u64(170);
-    let __v_15: G = G::from_u64(189);
-    let __v_16: G = G::from_u64(5);
-    let __v_17: G = G::from_u64(32);
-    let __v_18: G = G::from_u64(230);
-    let __v_19: G = G::from_u64(81);
-    let __v_20: G = G::from_u64(91);
-    let __v_21: G = G::from_u64(121);
-    let __v_22: G = G::from_u64(252);
-    let __v_23: G = G::from_u64(138);
-    let __v_24: G = G::from_u64(90);
-    let __v_25: G = G::from_u64(158);
-    let __v_26: G = G::from_u64(113);
-    let __v_27: G = G::from_u64(56);
-    let __v_28: G = G::from_u64(102);
-    let __v_29: G = G::from_u64(244);
-    let __v_30: G = G::from_u64(198);
-    let __v_31: G = G::from_u64(62);
-    let __v_32: G = { let __values: [G; 32] = [__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]; 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_303] = [__v_32];
-    record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
+    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_208] = [__v_1];
+        record.function_queries[208].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[210].get_mut(&__args[..]) { 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_5: G = __r_arr[0];
+        let __v_6: G = __r_arr[1];
+        let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_6, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { 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_7: G = __r_arr[0];
+        let __ret: [G; OUT_208] = [__v_7];
+        record.function_queries[208].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
   })
 }
 
-const INPUT_SIZE_304: usize = 1;
-const IN_304: usize = 1;
-const OUT_304: usize = 1;
-fn aiur_fn_304(
-  inp: [G; IN_304],
+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_304], ExecError> {
+) -> Result<[G; OUT_209], 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 };
-    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];
-    match __v_1.as_canonical_u64() {
-      1u64 => {
-        let __v_11: G = G::from_u64(0);
-        let __v_12: G = G::from_u64(1);
-        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 = 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(1);
-        let __v_21: G = G::from_u64(1);
-        let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; 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_23: G = { let __values: [G; 10] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_22]; 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_304] = [__v_23];
-        record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
+    let __v_1: G = G::from_u64(128);
+    let __v_2: G = if unconstrained { Bytes2::less_than(&__v_0, &__v_1) } else { bytes2_less_than_value(__v_0, __v_1, record) };
+    match __v_2.as_canonical_u64() {
       0u64 => {
-        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 = G::from_u64(0);
-        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 __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__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]; let __cu = unconstrained; if let Some(result) = record.function_queries[10].get_mut(&__args[..]) { 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_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];
-        match __v_27.as_canonical_u64() {
-          0u64 => {
-            let __v_28: G = G::from_u64(0);
-            let __v_29: G = { let __values: [G; 10] = [__v_28, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_10]; 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_304] = [__v_29];
-            record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __v_3: G = G::from_u64(192);
+        let __v_4: G = if unconstrained { Bytes2::less_than(&__v_0, &__v_3) } else { bytes2_less_than_value(__v_0, __v_3, record) };
+        match __v_4.as_canonical_u64() {
+          1u64 => {
+            let __v_5: G = G::from_u64(128);
+            let __v_6: G = (__v_0 - __v_5);
+            let __ret: [G; OUT_209] = [__v_6];
+            record.function_queries[209].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __v_28: G = G::from_u64(0);
-            let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[304].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_304] = unsafe { *(result.output.as_ptr() as *const [G; OUT_304]) }; __ret } else { aiur_fn_304(__args, record, io_buffer, __cu)? } };
-            let __v_29: G = __r_arr[0];
-            let __v_30: G = { let __values: [G; 10] = [__v_28, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_29]; 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_304] = [__v_30];
-            record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
+            return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
           },
         }
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_305: usize = 3;
-const IN_305: usize = 3;
-const OUT_305: usize = 1;
-fn aiur_fn_305(
-  inp: [G; IN_305],
+const INPUT_SIZE_210: usize = 2;
+const IN_210: usize = 2;
+const OUT_210: usize = 2;
+fn aiur_fn_210(
+  inp: [G; IN_210],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_305], 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];
-    let __v_2: G = inp[2];
-    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_3: G = __loaded[0];
-    let __v_4: G = __loaded[1];
-    let __v_5: G = __loaded[2];
-    let __v_6: G = __loaded[3];
-    let __v_7: G = __loaded[4];
-    let __v_8: G = __loaded[5];
-    let __v_9: G = __loaded[6];
-    let __v_10: G = __loaded[7];
-    let __v_11: G = __loaded[8];
-    let __v_12: G = __loaded[9];
+    let __v_2: G = G::from_u64(128);
+    let __v_3: G = if unconstrained { Bytes2::less_than(&__v_0, &__v_2) } else { bytes2_less_than_value(__v_0, __v_2, record) };
     match __v_3.as_canonical_u64() {
       1u64 => {
-        match __v_2.as_canonical_u64() {
+        let __ret: [G; OUT_210] = [__v_0, __v_1];
+        record.function_queries[210].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __v_4: G = G::from_u64(194);
+        let __v_5: G = if unconstrained { Bytes2::less_than(&__v_0, &__v_4) } else { bytes2_less_than_value(__v_0, __v_4, record) };
+        match __v_5.as_canonical_u64() {
           0u64 => {
-            let __ret: [G; OUT_305] = [__v_1];
-            record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
+            let __v_6: G = G::from_u64(224);
+            let __v_7: G = if unconstrained { Bytes2::less_than(&__v_0, &__v_6) } else { bytes2_less_than_value(__v_0, __v_6, record) };
+            match __v_7.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_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_8: G = __loaded[0];
+                let __v_9: G = __loaded[1];
+                let __v_10: G = __loaded[2];
+                match __v_8.as_canonical_u64() {
+                  0u64 => {
+                    let __v_11: G = G::from_u64(192);
+                    let __v_12: G = (__v_0 - __v_11);
+                    let __v_13: G = G::from_u64(64);
+                    let __v_14: G = (__v_12 * __v_13);
+                    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 !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_15: G = __r_arr[0];
+                    let __v_16: G = (__v_14 + __v_15);
+                    let __ret: [G; OUT_210] = [__v_16, __v_10];
+                    record.function_queries[210].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
+                  },
+                  _ => {
+                    return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64()));
+                  },
+                }
+              },
+              _ => {
+                let __v_8: G = G::from_u64(240);
+                let __v_9: G = if unconstrained { Bytes2::less_than(&__v_0, &__v_8) } else { bytes2_less_than_value(__v_0, __v_8, record) };
+                match __v_9.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_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_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 __v_16: G = G::from_u64(224);
+                            let __v_17: G = (__v_0 - __v_16);
+                            let __v_18: G = G::from_u64(4096);
+                            let __v_19: G = (__v_17 * __v_18);
+                            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 !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_20: G = __r_arr[0];
+                            let __v_21: G = G::from_u64(64);
+                            let __v_22: G = (__v_20 * __v_21);
+                            let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[209].get_mut(&__args[..]) { 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 = (__v_22 + __v_23);
+                            let __v_25: G = (__v_19 + __v_24);
+                            let __v_26: G = G::from_u64(2048);
+                            let __v_27: G = { let __a_val = __v_25.as_canonical_u64(); let __b_val = __v_26.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_27.as_canonical_u64() {
+                              0u64 => {
+                                let __ret: [G; OUT_210] = [__v_25, __v_15];
+                                record.function_queries[210].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                return Ok(__ret);
+                              },
+                              _ => {
+                                return Err(ExecError::MatchNoCase(__v_27.as_canonical_u64()));
+                              },
+                            }
+                          },
+                          _ => {
+                            return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64()));
+                          },
+                        }
+                      },
+                      _ => {
+                        return Err(ExecError::MatchNoCase(__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_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_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 __v_19: G = G::from_u64(240);
+                                let __v_20: G = (__v_0 - __v_19);
+                                let __v_21: G = G::from_u64(262144);
+                                let __v_22: G = (__v_20 * __v_21);
+                                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 !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_u64(4096);
+                                let __v_25: G = (__v_23 * __v_24);
+                                let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[209].get_mut(&__args[..]) { 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_26: G = __r_arr[0];
+                                let __v_27: G = G::from_u64(64);
+                                let __v_28: G = (__v_26 * __v_27);
+                                let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[209].get_mut(&__args[..]) { 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_29: G = __r_arr[0];
+                                let __v_30: G = (__v_28 + __v_29);
+                                let __v_31: G = (__v_25 + __v_30);
+                                let __v_32: G = (__v_22 + __v_31);
+                                let __v_33: G = G::from_u64(65536);
+                                let __v_34: G = { let __a_val = __v_32.as_canonical_u64(); let __b_val = __v_33.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_34.as_canonical_u64() {
+                                  0u64 => {
+                                    let __ret: [G; OUT_210] = [__v_32, __v_18];
+                                    record.function_queries[210].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                    return Ok(__ret);
+                                  },
+                                  _ => {
+                                    return Err(ExecError::MatchNoCase(__v_34.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()));
+                      },
+                    }
+                  },
+                }
+              },
+            }
           },
           _ => {
-            let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[304].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_304] = unsafe { *(result.output.as_ptr() as *const [G; OUT_304]) }; __ret } else { aiur_fn_304(__args, record, io_buffer, __cu)? } };
-            let __v_13: G = __r_arr[0];
-            let __ret: [G; OUT_305] = [__v_13];
-            record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
+            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
           },
         }
       },
+    }
+  })
+}
+
+const INPUT_SIZE_211: usize = 1;
+const IN_211: usize = 1;
+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_211], 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(0);
+    let __v_3: G = { let __values: [G; 3] = [__v_1, __v_2, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    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 __v_8: G = { let __values: [G; 3] = [__v_4, __v_3, __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 __v_9: G = G::from_u64(2);
+    let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[193].get_mut(&__args[..]) { 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_10: G = __r_arr[0];
+    let __v_11: G = G::from_u64(0);
+    let __v_12: G = { let __values: [G; 4] = [__v_9, __v_10, __v_8, __v_11]; 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_13: G = G::from_u64(2);
+    let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { 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_14: G = __r_arr[0];
+    let __v_15: G = G::from_u64(0);
+    let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_8, __v_15]; 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_17: G = G::from_u64(2);
+    let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[195].get_mut(&__args[..]) { 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_18: G = __r_arr[0];
+    let __v_19: G = G::from_u64(1);
+    let __v_20: G = G::from_u64(1);
+    let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __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 = G::from_u64(0);
+    let __v_23: G = { let __values: [G; 4] = [__v_17, __v_18, __v_21, __v_22]; 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_24: G = G::from_u64(2);
+    let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { 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_25: G = __r_arr[0];
+    let __v_26: G = G::from_u64(1);
+    let __v_27: G = G::from_u64(1);
+    let __v_28: G = { let __values: [G; 3] = [__v_26, __v_27, __v_27]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_29: G = G::from_u64(0);
+    let __v_30: G = { let __values: [G; 4] = [__v_24, __v_25, __v_28, __v_29]; 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_31: G = G::from_u64(2);
+    let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[191].get_mut(&__args[..]) { 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_32: G = __r_arr[0];
+    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 = { let __values: [G; 4] = [__v_31, __v_32, __v_35, __v_36]; 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_38: G = G::from_u64(3);
+    let __v_39: G = G::from_u64(0);
+    let __v_40: G = { let __values: [G; 4] = [__v_38, __v_12, __v_23, __v_39]; 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_41: G = G::from_u64(3);
+    let __v_42: G = G::from_u64(0);
+    let __v_43: G = { let __values: [G; 4] = [__v_41, __v_16, __v_23, __v_42]; 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_212] = { let __args: [G; IN_212] = [__v_0, __v_40, __v_43, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[212].get_mut(&__args[..]) { 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_44: G = __r_arr[0];
+    let __v_45: G = G::from_u64(3);
+    let __v_46: G = G::from_u64(0);
+    let __v_47: G = { let __values: [G; 4] = [__v_45, __v_37, __v_44, __v_46]; 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_211] = [__v_47];
+    record.function_queries[211].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_212: usize = 4;
+const IN_212: usize = 4;
+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_212], 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_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_4: G = __loaded[0];
+    let __v_5: G = __loaded[1];
+    let __v_6: G = __loaded[2];
+    match __v_4.as_canonical_u64() {
+      1u64 => {
+        let __ret: [G; OUT_212] = [__v_1];
+        record.function_queries[212].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_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: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
-        let __v_13: G = __loaded[0];
-        let __v_14: G = __loaded[1];
-        let __v_15: G = __loaded[2];
-        let __v_16: G = __loaded[3];
-        let __v_17: G = __loaded[4];
-        let __v_18: G = __loaded[5];
-        let __v_19: G = __loaded[6];
-        let __v_20: G = __loaded[7];
-        let __v_21: G = __loaded[8];
-        let __v_22: G = __loaded[9];
-        match __v_13.as_canonical_u64() {
-          1u64 => {
-            match __v_2.as_canonical_u64() {
-              0u64 => {
-                let __ret: [G; OUT_305] = [__v_0];
-                record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
+        let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[210].get_mut(&__args[..]) { 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_7: G = __r_arr[0];
+        let __v_8: G = __r_arr[1];
+        let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[216].get_mut(&__args[..]) { 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(7);
+        let __v_11: G = G::from_u64(0);
+        let __v_12: G = G::from_u64(0);
+        let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_9, __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 __v_14: G = G::from_u64(3);
+        let __v_15: G = G::from_u64(0);
+        let __v_16: G = { let __values: [G; 4] = [__v_14, __v_3, __v_13, __v_15]; 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_17: G = G::from_u64(3);
+        let __v_18: G = G::from_u64(0);
+        let __v_19: G = { let __values: [G; 4] = [__v_17, __v_2, __v_16, __v_18]; 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_212] = { let __args: [G; IN_212] = [__v_8, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[212].get_mut(&__args[..]) { 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_20: G = __r_arr[0];
+        let __v_21: G = G::from_u64(3);
+        let __v_22: G = G::from_u64(0);
+        let __v_23: G = { let __values: [G; 4] = [__v_21, __v_19, __v_20, __v_22]; 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_212] = [__v_23];
+        record.function_queries[212].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_213: usize = 2;
+const IN_213: usize = 2;
+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_213], 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() {
+      3u64 => {
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; 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: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].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];
+        match __v_6.as_canonical_u64() {
+          2u64 => {
+            let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[258].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_258] = unsafe { *(result.output.as_ptr() as *const [G; OUT_258]) }; __ret } else { aiur_fn_258(__args, record, io_buffer, __cu)? } };
+            let __v_10: G = __r_arr[0];
+            let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; 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: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].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];
+            let __v_21: G = __loaded[10];
+            let __v_22: G = __loaded[11];
+            match __v_11.as_canonical_u64() {
+              1u64 => {
+                let __v_23: G = G::from_u64(1);
+                let __v_24: G = G::from_u64(1);
+                let __v_25: G = { let __values: [G; 3] = [__v_23, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_307] = { let __args: [G; IN_307] = [__v_14, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } else { aiur_fn_307(__args, record, io_buffer, __cu)? } };
+                let __v_26: 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_26.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).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_27: G = __loaded[0];
+                let __v_28: G = __loaded[1];
+                let __v_29: G = __loaded[2];
+                let __v_30: G = __loaded[3];
+                match __v_27.as_canonical_u64() {
+                  4u64 => {
+                    let __v_31: G = G::from_u64(0);
+                    let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_29, __v_4, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[331].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_331] = unsafe { *(result.output.as_ptr() as *const [G; OUT_331]) }; __ret } else { aiur_fn_331(__args, record, io_buffer, __cu)? } };
+                    let __v_32: G = __r_arr[0];
+                    let __r_arr: [G; OUT_379] = { let __args: [G; IN_379] = [__v_32, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[379].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_379] = unsafe { *(result.output.as_ptr() as *const [G; OUT_379]) }; __ret } else { aiur_fn_379(__args, record, io_buffer, __cu)? } };
+                    let __v_33: G = __r_arr[0];
+                    let __ret: [G; OUT_213] = [__v_33];
+                    record.function_queries[213].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
+                  },
+                  _ => {
+                    let __v_31: G = G::from_u64(3);
+                    let __v_32: G = G::from_u64(0);
+                    let __v_33: G = { let __values: [G; 4] = [__v_31, __v_26, __v_4, __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 __r_arr: [G; OUT_379] = { let __args: [G; IN_379] = [__v_33, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[379].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_379] = unsafe { *(result.output.as_ptr() as *const [G; OUT_379]) }; __ret } else { aiur_fn_379(__args, record, io_buffer, __cu)? } };
+                    let __v_34: G = __r_arr[0];
+                    let __ret: [G; OUT_213] = [__v_34];
+                    record.function_queries[213].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
+                  },
+                }
               },
               _ => {
-                let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[304].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_304] = unsafe { *(result.output.as_ptr() as *const [G; OUT_304]) }; __ret } else { aiur_fn_304(__args, record, io_buffer, __cu)? } };
-                let __v_23: G = __r_arr[0];
-                let __ret: [G; OUT_305] = [__v_23];
-                record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_213] = [__v_0];
+                record.function_queries[213].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
-          0u64 => {
-            let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[10].get_mut(&__args[..]) { 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_23: G = __r_arr[0];
-            let __v_24: G = __r_arr[1];
-            let __v_25: G = __r_arr[2];
-            let __v_26: G = __r_arr[3];
-            let __v_27: G = __r_arr[4];
-            let __v_28: G = __r_arr[5];
-            let __v_29: G = __r_arr[6];
-            let __v_30: G = __r_arr[7];
-            let __v_31: G = __r_arr[8];
-            let __v_32: G = G::from_u64(0);
-            let __v_33: G = G::from_u64(0);
-            let __v_34: G = G::from_u64(0);
-            let __v_35: G = G::from_u64(0);
-            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 __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_2, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[10].get_mut(&__args[..]) { 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_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 = (__v_31 + __v_47);
-            let __v_49: G = G::from_u64(0);
-            let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_12, __v_22, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = unsafe { *(result.output.as_ptr() as *const [G; OUT_305]) }; __ret } else { aiur_fn_305(__args, record, io_buffer, __cu)? } };
-            let __v_50: G = __r_arr[0];
-            let __v_51: G = { let __values: [G; 10] = [__v_49, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_50]; 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_305] = [__v_51];
-            record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+          _ => {
+            let __ret: [G; OUT_213] = [__v_0];
+            record.function_queries[213].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+        }
+      },
+      _ => {
+        let __ret: [G; OUT_213] = [__v_0];
+        record.function_queries[213].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_214: usize = 2;
+const IN_214: usize = 2;
+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_214], 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() {
+      7u64 => {
+        match __v_3.as_canonical_u64() {
+          1u64 => {
+            let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[211].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { 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_7: G = __r_arr[0];
+            let __ret: [G; OUT_214] = [__v_7];
+            record.function_queries[214].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64()));
+            let __ret: [G; OUT_214] = [__v_0];
+            record.function_queries[214].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
           },
         }
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
+        let __ret: [G; OUT_214] = [__v_0];
+        record.function_queries[214].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_306: usize = 2;
-const IN_306: usize = 2;
-const OUT_306: usize = 1;
-fn aiur_fn_306(
-  inp: [G; IN_306],
+const INPUT_SIZE_215: usize = 1;
+const IN_215: usize = 1;
+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_306], 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 __v_2: G = G::from_u64(0);
-    let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = unsafe { *(result.output.as_ptr() as *const [G; OUT_305]) }; __ret } else { aiur_fn_305(__args, record, io_buffer, __cu)? } };
-    let __v_3: G = __r_arr[0];
-    let __ret: [G; OUT_306] = [__v_3];
-    record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __v_1: G = G::from_u64(0);
+    let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[117].get_mut(&__args[..]) { 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_2: G = __r_arr[0];
+    let __v_3: G = __r_arr[1];
+    let __v_4: G = G::from_u64(0);
+    let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[117].get_mut(&__args[..]) { 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 __v_6: G = __r_arr[1];
+    let __v_7: G = G::from_u64(0);
+    let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[117].get_mut(&__args[..]) { 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_8: G = __r_arr[0];
+    let __v_9: G = __r_arr[1];
+    let __v_10: G = G::from_u64(0);
+    let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[117].get_mut(&__args[..]) { 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_11: G = __r_arr[0];
+    let __v_12: G = __r_arr[1];
+    let __ret: [G; OUT_215] = [__v_2, __v_5, __v_8, __v_11];
+    record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_307: usize = 16;
-const IN_307: usize = 16;
-const OUT_307: usize = 9;
-fn aiur_fn_307(
-  inp: [G; IN_307],
+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_307], ExecError> {
+) -> Result<[G; OUT_216], 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 __b2_sub: (G, G) = if unconstrained { Bytes2::sub(&__v_0, &__v_8) } else { bytes2_sub_value(__v_0, __v_8, record) };
-    let __v_16: G = __b2_sub.0;
-    let __v_17: G = __b2_sub.1;
-    let __b2_sub: (G, G) = if unconstrained { Bytes2::sub(&__v_1, &__v_9) } else { bytes2_sub_value(__v_1, __v_9, record) };
-    let __v_18: G = __b2_sub.0;
-    let __v_19: G = __b2_sub.1;
-    let __b2_sub: (G, G) = if unconstrained { Bytes2::sub(&__v_18, &__v_17) } else { bytes2_sub_value(__v_18, __v_17, record) };
-    let __v_20: G = __b2_sub.0;
-    let __v_21: G = __b2_sub.1;
-    let __v_22: G = (__v_19 + __v_21);
-    let __b2_sub: (G, G) = if unconstrained { Bytes2::sub(&__v_2, &__v_10) } else { bytes2_sub_value(__v_2, __v_10, record) };
-    let __v_23: G = __b2_sub.0;
-    let __v_24: G = __b2_sub.1;
-    let __b2_sub: (G, G) = if unconstrained { Bytes2::sub(&__v_23, &__v_22) } else { bytes2_sub_value(__v_23, __v_22, record) };
-    let __v_25: G = __b2_sub.0;
-    let __v_26: G = __b2_sub.1;
-    let __v_27: G = (__v_24 + __v_26);
-    let __b2_sub: (G, G) = if unconstrained { Bytes2::sub(&__v_3, &__v_11) } else { bytes2_sub_value(__v_3, __v_11, record) };
-    let __v_28: G = __b2_sub.0;
-    let __v_29: G = __b2_sub.1;
-    let __b2_sub: (G, G) = if unconstrained { Bytes2::sub(&__v_28, &__v_27) } else { bytes2_sub_value(__v_28, __v_27, record) };
-    let __v_30: G = __b2_sub.0;
-    let __v_31: G = __b2_sub.1;
-    let __v_32: G = (__v_29 + __v_31);
-    let __b2_sub: (G, G) = if unconstrained { Bytes2::sub(&__v_4, &__v_12) } else { bytes2_sub_value(__v_4, __v_12, record) };
-    let __v_33: G = __b2_sub.0;
-    let __v_34: G = __b2_sub.1;
-    let __b2_sub: (G, G) = if unconstrained { Bytes2::sub(&__v_33, &__v_32) } else { bytes2_sub_value(__v_33, __v_32, record) };
-    let __v_35: G = __b2_sub.0;
-    let __v_36: G = __b2_sub.1;
-    let __v_37: G = (__v_34 + __v_36);
-    let __b2_sub: (G, G) = if unconstrained { Bytes2::sub(&__v_5, &__v_13) } else { bytes2_sub_value(__v_5, __v_13, record) };
-    let __v_38: G = __b2_sub.0;
-    let __v_39: G = __b2_sub.1;
-    let __b2_sub: (G, G) = if unconstrained { Bytes2::sub(&__v_38, &__v_37) } else { bytes2_sub_value(__v_38, __v_37, record) };
-    let __v_40: G = __b2_sub.0;
-    let __v_41: G = __b2_sub.1;
-    let __v_42: G = (__v_39 + __v_41);
-    let __b2_sub: (G, G) = if unconstrained { Bytes2::sub(&__v_6, &__v_14) } else { bytes2_sub_value(__v_6, __v_14, record) };
-    let __v_43: G = __b2_sub.0;
-    let __v_44: G = __b2_sub.1;
-    let __b2_sub: (G, G) = if unconstrained { Bytes2::sub(&__v_43, &__v_42) } else { bytes2_sub_value(__v_43, __v_42, record) };
-    let __v_45: G = __b2_sub.0;
-    let __v_46: G = __b2_sub.1;
-    let __v_47: G = (__v_44 + __v_46);
-    let __b2_sub: (G, G) = if unconstrained { Bytes2::sub(&__v_7, &__v_15) } else { bytes2_sub_value(__v_7, __v_15, record) };
-    let __v_48: G = __b2_sub.0;
-    let __v_49: G = __b2_sub.1;
-    let __b2_sub: (G, G) = if unconstrained { Bytes2::sub(&__v_48, &__v_47) } else { bytes2_sub_value(__v_48, __v_47, record) };
-    let __v_50: G = __b2_sub.0;
-    let __v_51: G = __b2_sub.1;
-    let __v_52: G = (__v_49 + __v_51);
-    let __ret: [G; OUT_307] = [__v_16, __v_20, __v_25, __v_30, __v_35, __v_40, __v_45, __v_50, __v_52];
-    record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[215].get_mut(&__args[..]) { 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_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 = G::from_u64(0);
+    let __v_6: G = if unconstrained { Bytes2::xor(&__v_1, &__v_5) } else { bytes2_xor_value(__v_1, __v_5, record) };
+    let __v_7: G = G::from_u64(0);
+    let __v_8: G = if unconstrained { Bytes2::xor(&__v_2, &__v_7) } else { bytes2_xor_value(__v_2, __v_7, record) };
+    let __v_9: G = G::from_u64(0);
+    let __v_10: G = if unconstrained { Bytes2::xor(&__v_3, &__v_9) } else { bytes2_xor_value(__v_3, __v_9, record) };
+    let __v_11: G = G::from_u64(0);
+    let __v_12: G = if unconstrained { Bytes2::xor(&__v_4, &__v_11) } else { bytes2_xor_value(__v_4, __v_11, record) };
+    let __v_13: G = G::from_u64(256);
+    let __v_14: G = (__v_13 * __v_8);
+    let __v_15: G = G::from_u64(65536);
+    let __v_16: G = (__v_15 * __v_10);
+    let __v_17: G = G::from_u64(16777216);
+    let __v_18: G = (__v_17 * __v_12);
+    let __v_19: G = (__v_16 + __v_18);
+    let __v_20: G = (__v_14 + __v_19);
+    let __v_21: G = (__v_6 + __v_20);
+    if (__v_0 != __v_21) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_0.as_canonical_u64(), rhs: __v_21.as_canonical_u64(), msg: Some("u32 byte split does not recompose to the original value".to_string()) });
+    }
+    let __v_22: G = G::from_u64(0);
+    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 __v_26: G = G::from_u64(0);
+    let __v_27: G = G::from_u64(1);
+    let __v_28: G = G::from_u64(1);
+    let __v_29: G = { let __values: [G; 10] = [__v_27, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28]; 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_30: G = { let __values: [G; 10] = [__v_22, __v_6, __v_8, __v_10, __v_12, __v_23, __v_24, __v_25, __v_26, __v_29]; 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_216] = [__v_30];
+    record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_308: usize = 3;
-const IN_308: usize = 3;
-const OUT_308: usize = 2;
-fn aiur_fn_308(
-  inp: [G; IN_308],
+const INPUT_SIZE_217: usize = 2;
+const IN_217: usize = 2;
+const OUT_217: usize = 2;
+fn aiur_fn_217(
+  inp: [G; IN_217],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_308], ExecError> {
+) -> Result<[G; OUT_217], 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; 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_3: G = __loaded[0];
-    let __v_4: G = __loaded[1];
-    let __v_5: G = __loaded[2];
-    let __v_6: G = __loaded[3];
-    let __v_7: G = __loaded[4];
-    let __v_8: G = __loaded[5];
-    let __v_9: G = __loaded[6];
-    let __v_10: G = __loaded[7];
-    let __v_11: G = __loaded[8];
-    let __v_12: G = __loaded[9];
-    match __v_3.as_canonical_u64() {
-      1u64 => {
-        let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; 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: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
-        let __v_13: G = __loaded[0];
-        let __v_14: G = __loaded[1];
-        let __v_15: G = __loaded[2];
-        let __v_16: G = __loaded[3];
-        let __v_17: G = __loaded[4];
-        let __v_18: G = __loaded[5];
-        let __v_19: G = __loaded[6];
-        let __v_20: G = __loaded[7];
-        let __v_21: G = __loaded[8];
-        let __v_22: G = __loaded[9];
-        match __v_13.as_canonical_u64() {
+    let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = unsafe { *(result.output.as_ptr() as *const [G; OUT_377]) }; __ret } else { aiur_fn_377(__args, record, io_buffer, __cu)? } };
+    let __v_2: G = __r_arr[0];
+    let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[106].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_106] = unsafe { *(result.output.as_ptr() as *const [G; OUT_106]) }; __ret } else { aiur_fn_106(__args, record, io_buffer, __cu)? } };
+    let __v_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; 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: 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() {
+      2u64 => {
+        let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[193].get_mut(&__args[..]) { 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_9: G = __r_arr[0];
+        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_10: G = __r_arr[0];
+        match __v_10.as_canonical_u64() {
           1u64 => {
-            let __v_23: G = G::from_u64(1);
-            let __v_24: G = G::from_u64(1);
-            let __v_25: G = { let __values: [G; 10] = [__v_23, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24]; 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_308] = [__v_25, __v_2];
-            record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          0u64 => {
-            let __v_23: G = G::from_u64(1);
-            let __v_24: G = G::from_u64(1);
-            let __v_25: G = { let __values: [G; 10] = [__v_23, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24]; 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_26: G = G::from_u64(1);
-            let __ret: [G; OUT_308] = [__v_25, __v_26];
-            record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
+            let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } else { aiur_fn_711(__args, record, io_buffer, __cu)? } };
+            let __v_11: G = __r_arr[0];
+            match __v_11.as_canonical_u64() {
+              1u64 => {
+                let __v_12: G = G::from_u64(1);
+                let __v_13: G = G::from_u64(1);
+                let __v_14: G = G::from_u64(1);
+                let __v_15: G = { let __values: [G; 3] = [__v_13, __v_14, __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_217] = [__v_12, __v_15];
+                record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                let __v_12: G = G::from_u64(0);
+                let __v_13: G = G::from_u64(1);
+                let __v_14: G = G::from_u64(1);
+                let __v_15: G = { let __values: [G; 3] = [__v_13, __v_14, __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_217] = [__v_12, __v_15];
+                record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+            }
           },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64()));
+            let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { 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_11: G = __r_arr[0];
+            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_12: G = __r_arr[0];
+            match __v_12.as_canonical_u64() {
+              0u64 => {
+                let __v_13: G = G::from_u64(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 __ret: [G; OUT_217] = [__v_13, __v_16];
+                record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } else { aiur_fn_711(__args, record, io_buffer, __cu)? } };
+                let __v_13: G = __r_arr[0];
+                match __v_13.as_canonical_u64() {
+                  3u64 => {
+                    let __v_14: G = G::from_u64(1);
+                    let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_4, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } };
+                    let __v_15: G = __r_arr[0];
+                    let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_15, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[218].get_mut(&__args[..]) { 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_16: G = __r_arr[0];
+                    let __v_17: G = __r_arr[1];
+                    match __v_16.as_canonical_u64() {
+                      0u64 => {
+                        let __v_18: G = G::from_u64(0);
+                        let __v_19: G = G::from_u64(1);
+                        let __v_20: G = G::from_u64(1);
+                        let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __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 __ret: [G; OUT_217] = [__v_18, __v_21];
+                        record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        return Ok(__ret);
+                      },
+                      1u64 => {
+                        let __v_18: G = G::from_u64(2);
+                        let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_4, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } };
+                        let __v_19: G = __r_arr[0];
+                        let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_19, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { 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_20: G = __r_arr[0];
+                        let __v_21: G = __r_arr[1];
+                        match __v_20.as_canonical_u64() {
+                          0u64 => {
+                            let __v_22: G = G::from_u64(0);
+                            let __ret: [G; OUT_217] = [__v_22, __v_21];
+                            record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            return Ok(__ret);
+                          },
+                          1u64 => {
+                            let __v_22: G = G::from_u64(1);
+                            let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_17, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[223].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_223] = unsafe { *(result.output.as_ptr() as *const [G; OUT_223]) }; __ret } else { aiur_fn_223(__args, record, io_buffer, __cu)? } };
+                            let __v_23: G = __r_arr[0];
+                            let __ret: [G; OUT_217] = [__v_22, __v_23];
+                            record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            return Ok(__ret);
+                          },
+                          _ => {
+                            return Err(ExecError::MatchNoCase(__v_20.as_canonical_u64()));
+                          },
+                        }
+                      },
+                      _ => {
+                        return Err(ExecError::MatchNoCase(__v_16.as_canonical_u64()));
+                      },
+                    }
+                  },
+                  _ => {
+                    let __v_14: G = G::from_u64(0);
+                    let __v_15: G = G::from_u64(1);
+                    let __v_16: G = G::from_u64(1);
+                    let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_217] = [__v_14, __v_17];
+                    record.function_queries[217].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_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: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
-        let __v_13: G = __loaded[0];
-        let __v_14: G = __loaded[1];
-        let __v_15: G = __loaded[2];
-        let __v_16: G = __loaded[3];
-        let __v_17: G = __loaded[4];
-        let __v_18: G = __loaded[5];
-        let __v_19: G = __loaded[6];
-        let __v_20: G = __loaded[7];
-        let __v_21: G = __loaded[8];
-        let __v_22: G = __loaded[9];
-        match __v_13.as_canonical_u64() {
-          1u64 => {
-            match __v_2.as_canonical_u64() {
+      _ => {
+        let __v_9: G = G::from_u64(0);
+        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_217] = [__v_9, __v_12];
+        record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_218: usize = 2;
+const IN_218: usize = 2;
+const OUT_218: usize = 2;
+fn aiur_fn_218(
+  inp: [G; IN_218],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> 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];
+    let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[219].get_mut(&__args[..]) { 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 __v_3: G = __r_arr[1];
+    match __v_2.as_canonical_u64() {
+      1u64 => {
+        let __v_4: G = G::from_u64(1);
+        let __ret: [G; OUT_218] = [__v_4, __v_3];
+        record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = unsafe { *(result.output.as_ptr() as *const [G; OUT_377]) }; __ret } else { aiur_fn_377(__args, record, io_buffer, __cu)? } };
+        let __v_4: G = __r_arr[0];
+        let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[219].get_mut(&__args[..]) { 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_5: G = __r_arr[0];
+        let __v_6: G = __r_arr[1];
+        let __ret: [G; OUT_218] = [__v_5, __v_6];
+        record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_219: usize = 1;
+const IN_219: usize = 1;
+const OUT_219: usize = 2;
+fn aiur_fn_219(
+  inp: [G; IN_219],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_219], 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() {
+      3u64 => {
+        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_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() {
+          2u64 => {
+            let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { 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_9: G = __r_arr[0];
+            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_10: G = __r_arr[0];
+            match __v_10.as_canonical_u64() {
               0u64 => {
-                let __v_23: G = G::from_u64(0);
-                let __ret: [G; OUT_308] = [__v_0, __v_23];
-                record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __v_11: G = G::from_u64(0);
+                let __v_12: G = G::from_u64(0);
+                let __ret: [G; OUT_219] = [__v_11, __v_12];
+                record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                let __v_23: G = G::from_u64(1);
-                let __v_24: G = G::from_u64(0);
-                let __v_25: G = G::from_u64(0);
-                let __v_26: G = G::from_u64(0);
-                let __v_27: G = G::from_u64(0);
-                let __v_28: G = G::from_u64(0);
-                let __v_29: G = G::from_u64(0);
-                let __v_30: G = G::from_u64(0);
-                let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } else { aiur_fn_307(__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 = G::from_u64(1);
-                let __v_41: G = G::from_u64(1);
-                let __v_42: G = { let __values: [G; 10] = [__v_40, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41]; 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_308] = { let __args: [G; IN_308] = [__v_12, __v_42, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[308].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_308] = unsafe { *(result.output.as_ptr() as *const [G; OUT_308]) }; __ret } else { aiur_fn_308(__args, record, io_buffer, __cu)? } };
-                let __v_43: G = __r_arr[0];
-                let __v_44: G = __r_arr[1];
-                let __v_45: G = G::from_u64(0);
-                let __v_46: G = { let __values: [G; 10] = [__v_45, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_43]; 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_308] = [__v_46, __v_44];
-                record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
+                let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; 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: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].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];
+                match __v_11.as_canonical_u64() {
+                  7u64 => {
+                    match __v_12.as_canonical_u64() {
+                      0u64 => {
+                        let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[220].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_220] = unsafe { *(result.output.as_ptr() as *const [G; OUT_220]) }; __ret } else { aiur_fn_220(__args, record, io_buffer, __cu)? } };
+                        let __v_15: G = __r_arr[0];
+                        let __v_16: G = __r_arr[1];
+                        let __ret: [G; OUT_219] = [__v_15, __v_16];
+                        record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        return Ok(__ret);
+                      },
+                      _ => {
+                        let __v_15: G = G::from_u64(0);
+                        let __v_16: G = G::from_u64(0);
+                        let __ret: [G; OUT_219] = [__v_15, __v_16];
+                        record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        return Ok(__ret);
+                      },
+                    }
+                  },
+                  _ => {
+                    let __v_15: G = G::from_u64(0);
+                    let __v_16: G = G::from_u64(0);
+                    let __ret: [G; OUT_219] = [__v_15, __v_16];
+                    record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
+                  },
+                }
               },
             }
           },
-          0u64 => {
-            let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } else { aiur_fn_307(__args, record, io_buffer, __cu)? } };
-            let __v_23: G = __r_arr[0];
-            let __v_24: G = __r_arr[1];
-            let __v_25: G = __r_arr[2];
-            let __v_26: G = __r_arr[3];
-            let __v_27: G = __r_arr[4];
-            let __v_28: G = __r_arr[5];
-            let __v_29: G = __r_arr[6];
-            let __v_30: G = __r_arr[7];
-            let __v_31: G = __r_arr[8];
-            let __v_32: G = G::from_u64(0);
-            let __v_33: G = G::from_u64(0);
-            let __v_34: G = G::from_u64(0);
-            let __v_35: G = G::from_u64(0);
-            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 __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_2, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } else { aiur_fn_307(__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 = (__v_31 + __v_47);
-            let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_12, __v_22, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[308].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_308] = unsafe { *(result.output.as_ptr() as *const [G; OUT_308]) }; __ret } else { aiur_fn_308(__args, record, io_buffer, __cu)? } };
-            let __v_49: G = __r_arr[0];
-            let __v_50: G = __r_arr[1];
-            let __v_51: G = G::from_u64(0);
-            let __v_52: G = { let __values: [G; 10] = [__v_51, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_49]; 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_308] = [__v_52, __v_50];
-            record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64()));
+            let __v_9: G = G::from_u64(0);
+            let __v_10: G = G::from_u64(0);
+            let __ret: [G; OUT_219] = [__v_9, __v_10];
+            record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
           },
         }
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
+        let __v_5: G = G::from_u64(0);
+        let __v_6: G = G::from_u64(0);
+        let __ret: [G; OUT_219] = [__v_5, __v_6];
+        record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_309: usize = 1;
-const IN_309: usize = 1;
-const OUT_309: usize = 1;
-fn aiur_fn_309(
-  inp: [G; IN_309],
+const INPUT_SIZE_220: usize = 1;
+const IN_220: usize = 1;
+const OUT_220: usize = 2;
+fn aiur_fn_220(
+  inp: [G; IN_220],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_309], ExecError> {
+) -> Result<[G; OUT_220], 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 };
@@ -28393,1335 +20501,1996 @@ fn aiur_fn_309(
     let __v_9: G = __loaded[8];
     let __v_10: G = __loaded[9];
     match __v_1.as_canonical_u64() {
-      1u64 => {
-        let __v_11: G = G::from_u64(1);
-        let __v_12: G = G::from_u64(1);
-        let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; 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_309] = [__v_13];
-        record.function_queries[309].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
       0u64 => {
-        let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } };
-        let __v_11: G = __r_arr[0];
-        let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).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_12: G = __loaded[0];
-        let __v_13: G = __loaded[1];
-        let __v_14: G = __loaded[2];
-        let __v_15: G = __loaded[3];
-        let __v_16: G = __loaded[4];
-        let __v_17: G = __loaded[5];
-        let __v_18: G = __loaded[6];
-        let __v_19: G = __loaded[7];
-        let __v_20: G = __loaded[8];
-        let __v_21: G = __loaded[9];
-        match __v_12.as_canonical_u64() {
+        let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; 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: 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_2] = { let __args: [G; IN_2] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
-            let __v_22: G = __r_arr[0];
-            match __v_22.as_canonical_u64() {
-              1u64 => {
-                let __v_23: G = G::from_u64(1);
-                let __v_24: G = G::from_u64(1);
-                let __v_25: G = { let __values: [G; 10] = [__v_23, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24]; 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_309] = [__v_25];
-                record.function_queries[309].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
+            let __v_21: G = (__v_8 + __v_9);
+            let __v_22: G = (__v_7 + __v_21);
+            let __v_23: G = (__v_6 + __v_22);
+            let __v_24: G = (__v_5 + __v_23);
+            let __v_25: G = G::from_bool((__v_24 == G::ZERO));
+            match __v_25.as_canonical_u64() {
               0u64 => {
-                let __v_23: G = G::from_u64(0);
-                let __v_24: G = G::from_u64(1);
-                let __v_25: G = G::from_u64(1);
-                let __v_26: G = { let __values: [G; 10] = [__v_24, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25]; 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_27: G = { let __values: [G; 10] = [__v_23, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_26]; 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_309] = [__v_27];
-                record.function_queries[309].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __v_26: G = G::from_u64(0);
+                let __v_27: G = G::from_u64(0);
+                let __ret: [G; OUT_220] = [__v_26, __v_27];
+                record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                return Err(ExecError::MatchNoCase(__v_22.as_canonical_u64()));
+                let __v_26: G = G::from_u64(256);
+                let __v_27: G = (__v_3 * __v_26);
+                let __v_28: G = G::from_u64(65536);
+                let __v_29: G = (__v_4 * __v_28);
+                let __v_30: G = (__v_27 + __v_29);
+                let __v_31: G = (__v_2 + __v_30);
+                let __v_32: G = G::from_u64(55296);
+                let __v_33: G = { let __a_val = __v_31.as_canonical_u64(); let __b_val = __v_32.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_33.as_canonical_u64() {
+                  1u64 => {
+                    let __v_34: G = G::from_u64(1);
+                    let __ret: [G; OUT_220] = [__v_34, __v_31];
+                    record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
+                  },
+                  _ => {
+                    let __v_34: G = G::from_u64(57343);
+                    let __v_35: G = { let __a_val = __v_34.as_canonical_u64(); let __b_val = __v_31.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_35.as_canonical_u64() {
+                      0u64 => {
+                        let __v_36: G = G::from_u64(0);
+                        let __v_37: G = G::from_u64(0);
+                        let __ret: [G; OUT_220] = [__v_36, __v_37];
+                        record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        return Ok(__ret);
+                      },
+                      _ => {
+                        let __v_36: G = G::from_u64(1114112);
+                        let __v_37: G = { let __a_val = __v_31.as_canonical_u64(); let __b_val = __v_36.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_37.as_canonical_u64() {
+                          1u64 => {
+                            let __v_38: G = G::from_u64(1);
+                            let __ret: [G; OUT_220] = [__v_38, __v_31];
+                            record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            return Ok(__ret);
+                          },
+                          _ => {
+                            let __v_38: G = G::from_u64(0);
+                            let __v_39: G = G::from_u64(0);
+                            let __ret: [G; OUT_220] = [__v_38, __v_39];
+                            record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            return Ok(__ret);
+                          },
+                        }
+                      },
+                    }
+                  },
+                }
               },
             }
           },
           _ => {
+            let __v_21: G = G::from_u64(0);
             let __v_22: G = G::from_u64(0);
-            let __v_23: G = { let __values: [G; 10] = [__v_22, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11]; 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_309] = [__v_23];
-            record.function_queries[309].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_220] = [__v_21, __v_22];
+            record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+        let __v_11: G = G::from_u64(0);
+        let __v_12: G = G::from_u64(0);
+        let __ret: [G; OUT_220] = [__v_11, __v_12];
+        record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_310: usize = 2;
-const IN_310: usize = 2;
-const OUT_310: usize = 1;
-fn aiur_fn_310(
-  inp: [G; IN_310],
+const INPUT_SIZE_221: usize = 2;
+const IN_221: usize = 2;
+const OUT_221: usize = 2;
+fn aiur_fn_221(
+  inp: [G; IN_221],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_310], ExecError> {
+) -> Result<[G; OUT_221], 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(0);
-    let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[308].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_308] = unsafe { *(result.output.as_ptr() as *const [G; OUT_308]) }; __ret } else { aiur_fn_308(__args, record, io_buffer, __cu)? } };
-    let __v_3: G = __r_arr[0];
-    let __v_4: G = __r_arr[1];
-    match __v_4.as_canonical_u64() {
+    let __v_2: G = G::from_u64(64);
+    let __v_3: G = { let __a_val = __v_0.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_3.as_canonical_u64() {
       1u64 => {
-        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_310] = [__v_7];
-        record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } };
-        let __v_5: G = __r_arr[0];
-        let __ret: [G; OUT_310] = [__v_5];
-        record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_221] = [__v_0, __v_1];
+        record.function_queries[221].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
+        let __v_4: G = G::from_u64(64);
+        let __v_5: G = (__v_0 - __v_4);
+        let __v_6: G = G::from_u64(1);
+        let __v_7: G = (__v_1 + __v_6);
+        let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[221].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_221] = unsafe { *(result.output.as_ptr() as *const [G; OUT_221]) }; __ret } else { aiur_fn_221(__args, record, io_buffer, __cu)? } };
+        let __v_8: G = __r_arr[0];
+        let __v_9: G = __r_arr[1];
+        let __ret: [G; OUT_221] = [__v_8, __v_9];
+        record.function_queries[221].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_311: usize = 2;
-const IN_311: usize = 2;
-const OUT_311: usize = 1;
-fn aiur_fn_311(
-  inp: [G; IN_311],
+const INPUT_SIZE_222: usize = 1;
+const IN_222: usize = 1;
+const OUT_222: usize = 4;
+fn aiur_fn_222(
+  inp: [G; IN_222],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_311], ExecError> {
+) -> Result<[G; OUT_222], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = G::from_u64(0);
+    let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[221].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_221] = unsafe { *(result.output.as_ptr() as *const [G; OUT_221]) }; __ret } else { aiur_fn_221(__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(0);
+    let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[221].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_221] = unsafe { *(result.output.as_ptr() as *const [G; OUT_221]) }; __ret } else { aiur_fn_221(__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(0);
+    let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[221].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_221] = unsafe { *(result.output.as_ptr() as *const [G; OUT_221]) }; __ret } else { aiur_fn_221(__args, record, io_buffer, __cu)? } };
+    let __v_8: G = __r_arr[0];
+    let __v_9: G = __r_arr[1];
+    let __ret: [G; OUT_222] = [__v_2, __v_5, __v_8, __v_9];
+    record.function_queries[222].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_223: usize = 2;
+const IN_223: usize = 2;
+const OUT_223: usize = 1;
+fn aiur_fn_223(
+  inp: [G; IN_223],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_223], 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_310] = { let __args: [G; IN_310] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } else { aiur_fn_310(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[222].get_mut(&__args[..]) { let __ret: [G; OUT_222] = unsafe { *(result.output.as_ptr() as *const [G; OUT_222]) }; __ret } else { aiur_fn_222(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
-    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_3: G = __loaded[0];
-    let __v_4: G = __loaded[1];
-    let __v_5: G = __loaded[2];
-    let __v_6: G = __loaded[3];
-    let __v_7: G = __loaded[4];
-    let __v_8: G = __loaded[5];
-    let __v_9: G = __loaded[6];
-    let __v_10: G = __loaded[7];
-    let __v_11: G = __loaded[8];
-    let __v_12: G = __loaded[9];
-    match __v_3.as_canonical_u64() {
+    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 = G::from_u64(0);
+    let __v_7: G = if unconstrained { Bytes2::xor(&__v_2, &__v_6) } else { bytes2_xor_value(__v_2, __v_6, record) };
+    let __v_8: G = G::from_u64(0);
+    let __v_9: G = if unconstrained { Bytes2::xor(&__v_3, &__v_8) } else { bytes2_xor_value(__v_3, __v_8, record) };
+    let __v_10: G = G::from_u64(0);
+    let __v_11: G = if unconstrained { Bytes2::xor(&__v_4, &__v_10) } else { bytes2_xor_value(__v_4, __v_10, record) };
+    let __v_12: G = G::from_u64(0);
+    let __v_13: G = if unconstrained { Bytes2::xor(&__v_5, &__v_12) } else { bytes2_xor_value(__v_5, __v_12, record) };
+    let __v_14: G = G::from_u64(64);
+    let __v_15: G = { let __a_val = __v_7.as_canonical_u64(); let __b_val = __v_14.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_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: Some("utf8 group 0 is not a 6-bit value".to_string()) });
+    }
+    let __v_17: G = G::from_u64(64);
+    let __v_18: G = { let __a_val = __v_9.as_canonical_u64(); let __b_val = __v_17.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_19: G = G::from_u64(1);
+    if (__v_18 != __v_19) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_18.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: Some("utf8 group 1 is not a 6-bit value".to_string()) });
+    }
+    let __v_20: G = G::from_u64(64);
+    let __v_21: G = { let __a_val = __v_11.as_canonical_u64(); let __b_val = __v_20.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_22: G = G::from_u64(1);
+    if (__v_21 != __v_22) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_21.as_canonical_u64(), rhs: __v_22.as_canonical_u64(), msg: Some("utf8 group 2 is not a 6-bit value".to_string()) });
+    }
+    let __v_23: G = G::from_u64(64);
+    let __v_24: G = { let __a_val = __v_13.as_canonical_u64(); let __b_val = __v_23.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_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: Some("utf8 group 3 is not a 6-bit value".to_string()) });
+    }
+    let __v_26: G = G::from_u64(64);
+    let __v_27: G = (__v_9 * __v_26);
+    let __v_28: G = G::from_u64(4096);
+    let __v_29: G = (__v_11 * __v_28);
+    let __v_30: G = G::from_u64(262144);
+    let __v_31: G = (__v_13 * __v_30);
+    let __v_32: G = (__v_29 + __v_31);
+    let __v_33: G = (__v_27 + __v_32);
+    let __v_34: G = (__v_7 + __v_33);
+    if (__v_0 != __v_34) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_0.as_canonical_u64(), rhs: __v_34.as_canonical_u64(), msg: Some("utf8 groups do not recompose to the codepoint".to_string()) });
+    }
+    let __v_35: G = G::from_u64(128);
+    let __v_36: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_35.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_36.as_canonical_u64() {
       1u64 => {
-        let __v_13: G = G::from_u64(1);
-        let __ret: [G; OUT_311] = [__v_13];
-        record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __v_37: G = G::from_u64(0);
+        let __v_38: G = { let __values: [G; 3] = [__v_37, __v_0, __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_223] = [__v_38];
+        record.function_queries[223].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __v_13: G = G::from_u64(0);
-        let __ret: [G; OUT_311] = [__v_13];
-        record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
+        let __v_37: G = G::from_u64(2048);
+        let __v_38: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_37.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_38.as_canonical_u64() {
+          1u64 => {
+            let __v_39: G = G::from_u64(128);
+            let __v_40: G = (__v_7 + __v_39);
+            let __v_41: G = G::from_u64(192);
+            let __v_42: G = (__v_9 + __v_41);
+            let __v_43: G = G::from_u64(0);
+            let __v_44: G = G::from_u64(0);
+            let __v_45: G = { let __values: [G; 3] = [__v_44, __v_40, __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 __v_46: G = { let __values: [G; 3] = [__v_43, __v_42, __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 __ret: [G; OUT_223] = [__v_46];
+            record.function_queries[223].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            let __v_39: G = G::from_u64(65536);
+            let __v_40: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_39.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_40.as_canonical_u64() {
+              1u64 => {
+                let __v_41: G = G::from_u64(128);
+                let __v_42: G = (__v_7 + __v_41);
+                let __v_43: G = G::from_u64(128);
+                let __v_44: G = (__v_9 + __v_43);
+                let __v_45: G = G::from_u64(224);
+                let __v_46: G = (__v_11 + __v_45);
+                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; 3] = [__v_49, __v_42, __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 __v_51: G = { let __values: [G; 3] = [__v_48, __v_44, __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_47, __v_46, __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 __ret: [G; OUT_223] = [__v_52];
+                record.function_queries[223].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                let __v_41: G = G::from_u64(128);
+                let __v_42: G = (__v_7 + __v_41);
+                let __v_43: G = G::from_u64(128);
+                let __v_44: G = (__v_9 + __v_43);
+                let __v_45: G = G::from_u64(128);
+                let __v_46: G = (__v_11 + __v_45);
+                let __v_47: G = G::from_u64(240);
+                let __v_48: G = (__v_13 + __v_47);
+                let __v_49: G = G::from_u64(0);
+                let __v_50: G = G::from_u64(0);
+                let __v_51: G = G::from_u64(0);
+                let __v_52: G = G::from_u64(0);
+                let __v_53: G = { let __values: [G; 3] = [__v_52, __v_42, __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 __v_54: G = { let __values: [G; 3] = [__v_51, __v_44, __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_50, __v_46, __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 = { let __values: [G; 3] = [__v_49, __v_48, __v_55]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_223] = [__v_56];
+                record.function_queries[223].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+            }
+          },
+        }
       },
     }
   })
 }
 
-const INPUT_SIZE_312: usize = 1;
-const IN_312: usize = 1;
-const OUT_312: usize = 1;
-fn aiur_fn_312(
-  inp: [G; IN_312],
+const INPUT_SIZE_224: usize = 1;
+const IN_224: usize = 1;
+const OUT_224: usize = 1;
+fn aiur_fn_224(
+  inp: [G; IN_224],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_312], ExecError> {
+) -> Result<[G; OUT_224], 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(1);
-    let __v_3: G = G::from_u64(0);
-    let __v_4: G = G::from_u64(0);
-    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(1);
-    let __v_11: G = G::from_u64(1);
-    let __v_12: G = { let __values: [G; 10] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; 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_13: G = { let __values: [G; 10] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12]; 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_310] = { let __args: [G; IN_310] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } else { aiur_fn_310(__args, record, io_buffer, __cu)? } };
-    let __v_14: G = __r_arr[0];
-    let __ret: [G; OUT_312] = [__v_14];
-    record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
+    let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[139].get_mut(&__args[..]) { 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_1: G = __r_arr[0];
+    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_2: G = __r_arr[0];
+    match __v_2.as_canonical_u64() {
+      1u64 => {
+        let __v_3: G = G::from_u64(1);
+        let __ret: [G; OUT_224] = [__v_3];
+        record.function_queries[224].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[140].get_mut(&__args[..]) { 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_3: G = __r_arr[0];
+        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_4: G = __r_arr[0];
+        match __v_4.as_canonical_u64() {
+          1u64 => {
+            let __v_5: G = G::from_u64(1);
+            let __ret: [G; OUT_224] = [__v_5];
+            record.function_queries[224].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[141].get_mut(&__args[..]) { 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_5: G = __r_arr[0];
+            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_6: G = __r_arr[0];
+            match __v_6.as_canonical_u64() {
+              1u64 => {
+                let __v_7: G = G::from_u64(1);
+                let __ret: [G; OUT_224] = [__v_7];
+                record.function_queries[224].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[142].get_mut(&__args[..]) { 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_7: G = __r_arr[0];
+                let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_8: G = __r_arr[0];
+                match __v_8.as_canonical_u64() {
+                  1u64 => {
+                    let __v_9: G = G::from_u64(1);
+                    let __ret: [G; OUT_224] = [__v_9];
+                    record.function_queries[224].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
+                  },
+                  _ => {
+                    let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[143].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_143] = unsafe { *(result.output.as_ptr() as *const [G; OUT_143]) }; __ret } else { aiur_fn_143(__args, record, io_buffer, __cu)? } };
+                    let __v_9: G = __r_arr[0];
+                    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_10: G = __r_arr[0];
+                    match __v_10.as_canonical_u64() {
+                      1u64 => {
+                        let __v_11: G = G::from_u64(1);
+                        let __ret: [G; OUT_224] = [__v_11];
+                        record.function_queries[224].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        return Ok(__ret);
+                      },
+                      _ => {
+                        let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } else { aiur_fn_147(__args, record, io_buffer, __cu)? } };
+                        let __v_11: G = __r_arr[0];
+                        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_12: G = __r_arr[0];
+                        match __v_12.as_canonical_u64() {
+                          1u64 => {
+                            let __v_13: G = G::from_u64(1);
+                            let __ret: [G; OUT_224] = [__v_13];
+                            record.function_queries[224].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            return Ok(__ret);
+                          },
+                          _ => {
+                            let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_14: G = __r_arr[0];
+                            match __v_14.as_canonical_u64() {
+                              1u64 => {
+                                let __v_15: G = G::from_u64(1);
+                                let __ret: [G; OUT_224] = [__v_15];
+                                record.function_queries[224].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                return Ok(__ret);
+                              },
+                              _ => {
+                                let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[144].get_mut(&__args[..]) { 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_15: G = __r_arr[0];
+                                let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_16: G = __r_arr[0];
+                                match __v_16.as_canonical_u64() {
+                                  1u64 => {
+                                    let __v_17: G = G::from_u64(1);
+                                    let __ret: [G; OUT_224] = [__v_17];
+                                    record.function_queries[224].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                    return Ok(__ret);
+                                  },
+                                  _ => {
+                                    let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[145].get_mut(&__args[..]) { 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_17: G = __r_arr[0];
+                                    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_18: G = __r_arr[0];
+                                    match __v_18.as_canonical_u64() {
+                                      1u64 => {
+                                        let __v_19: G = G::from_u64(1);
+                                        let __ret: [G; OUT_224] = [__v_19];
+                                        record.function_queries[224].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                        return Ok(__ret);
+                                      },
+                                      _ => {
+                                        let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[153].get_mut(&__args[..]) { 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_19: G = __r_arr[0];
+                                        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_20: G = __r_arr[0];
+                                        match __v_20.as_canonical_u64() {
+                                          1u64 => {
+                                            let __v_21: G = G::from_u64(1);
+                                            let __ret: [G; OUT_224] = [__v_21];
+                                            record.function_queries[224].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                            return Ok(__ret);
+                                          },
+                                          _ => {
+                                            let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[154].get_mut(&__args[..]) { 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_21: G = __r_arr[0];
+                                            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_22: G = __r_arr[0];
+                                            match __v_22.as_canonical_u64() {
+                                              1u64 => {
+                                                let __v_23: G = G::from_u64(1);
+                                                let __ret: [G; OUT_224] = [__v_23];
+                                                record.function_queries[224].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                return Ok(__ret);
+                                              },
+                                              _ => {
+                                                let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { 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_23: G = __r_arr[0];
+                                                let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_24: G = __r_arr[0];
+                                                match __v_24.as_canonical_u64() {
+                                                  1u64 => {
+                                                    let __v_25: G = G::from_u64(1);
+                                                    let __ret: [G; OUT_224] = [__v_25];
+                                                    record.function_queries[224].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                    return Ok(__ret);
+                                                  },
+                                                  _ => {
+                                                    let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { 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_25: G = __r_arr[0];
+                                                    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_26: G = __r_arr[0];
+                                                    match __v_26.as_canonical_u64() {
+                                                      1u64 => {
+                                                        let __v_27: G = G::from_u64(1);
+                                                        let __ret: [G; OUT_224] = [__v_27];
+                                                        record.function_queries[224].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                        return Ok(__ret);
+                                                      },
+                                                      _ => {
+                                                        let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { 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_27: G = __r_arr[0];
+                                                        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_28: G = __r_arr[0];
+                                                        match __v_28.as_canonical_u64() {
+                                                          1u64 => {
+                                                            let __v_29: G = G::from_u64(1);
+                                                            let __ret: [G; OUT_224] = [__v_29];
+                                                            record.function_queries[224].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                            return Ok(__ret);
+                                                          },
+                                                          _ => {
+                                                            let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[151].get_mut(&__args[..]) { 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_29: G = __r_arr[0];
+                                                            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_30: G = __r_arr[0];
+                                                            match __v_30.as_canonical_u64() {
+                                                              1u64 => {
+                                                                let __v_31: G = G::from_u64(1);
+                                                                let __ret: [G; OUT_224] = [__v_31];
+                                                                record.function_queries[224].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                return Ok(__ret);
+                                                              },
+                                                              _ => {
+                                                                let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { 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_31: G = __r_arr[0];
+                                                                let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_32: G = __r_arr[0];
+                                                                match __v_32.as_canonical_u64() {
+                                                                  1u64 => {
+                                                                    let __v_33: G = G::from_u64(1);
+                                                                    let __ret: [G; OUT_224] = [__v_33];
+                                                                    record.function_queries[224].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                    return Ok(__ret);
+                                                                  },
+                                                                  _ => {
+                                                                    let __v_33: G = G::from_u64(0);
+                                                                    let __ret: [G; OUT_224] = [__v_33];
+                                                                    record.function_queries[224].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                                    return Ok(__ret);
+                                                                  },
+                                                                }
+                                                              },
+                                                            }
+                                                          },
+                                                        }
+                                                      },
+                                                    }
+                                                  },
+                                                }
+                                              },
+                                            }
+                                          },
+                                        }
+                                      },
+                                    }
+                                  },
+                                }
+                              },
+                            }
+                          },
+                        }
+                      },
+                    }
+                  },
+                }
+              },
+            }
+          },
+        }
+      },
+    }
   })
 }
 
-const INPUT_SIZE_313: usize = 2;
-const IN_313: usize = 2;
-const OUT_313: usize = 2;
-fn aiur_fn_313(
-  inp: [G; IN_313],
+const INPUT_SIZE_225: usize = 1;
+const IN_225: usize = 1;
+const OUT_225: usize = 2;
+fn aiur_fn_225(
+  inp: [G; IN_225],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_313], ExecError> {
+) -> Result<[G; OUT_225], 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 = { let __a_val = __v_0.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_3.as_canonical_u64() {
-      1u64 => {
-        let __ret: [G; OUT_313] = [__v_0, __v_1];
-        record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
+    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() {
+      7u64 => {
+        match __v_2.as_canonical_u64() {
+          0u64 => {
+            let __v_5: G = G::from_u64(1);
+            let __ret: [G; OUT_225] = [__v_5, __v_3];
+            record.function_queries[225].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            let __v_5: G = G::from_u64(0);
+            let __v_6: G = G::from_u64(1);
+            let __v_7: G = G::from_u64(1);
+            let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; 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_225] = [__v_5, __v_8];
+            record.function_queries[225].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+        }
       },
-      0u64 => {
-        let __v_4: G = G::from_u64(256);
-        let __v_5: G = (__v_0 - __v_4);
-        let __v_6: G = G::from_u64(1);
-        let __v_7: G = (__v_1 + __v_6);
-        let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[313].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_313] = unsafe { *(result.output.as_ptr() as *const [G; OUT_313]) }; __ret } else { aiur_fn_313(__args, record, io_buffer, __cu)? } };
-        let __v_8: G = __r_arr[0];
-        let __v_9: G = __r_arr[1];
-        let __ret: [G; OUT_313] = [__v_8, __v_9];
-        record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+      2u64 => {
+        let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[138].get_mut(&__args[..]) { 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_5: G = __r_arr[0];
+        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_6: G = __r_arr[0];
+        match __v_6.as_canonical_u64() {
+          1u64 => {
+            let __v_7: G = G::from_u64(1);
+            let __v_8: G = G::from_u64(1);
+            let __v_9: G = G::from_u64(1);
+            let __v_10: G = { let __values: [G; 10] = [__v_8, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9]; 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_225] = [__v_7, __v_10];
+            record.function_queries[225].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            let __v_7: G = G::from_u64(0);
+            let __v_8: G = G::from_u64(1);
+            let __v_9: G = G::from_u64(1);
+            let __v_10: G = { let __values: [G; 10] = [__v_8, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9]; 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_225] = [__v_7, __v_10];
+            record.function_queries[225].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+        }
+      },
+      3u64 => {
+        let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } else { aiur_fn_226(__args, record, io_buffer, __cu)? } };
+        let __v_5: G = __r_arr[0];
+        let __v_6: G = __r_arr[1];
+        let __ret: [G; OUT_225] = [__v_5, __v_6];
+        record.function_queries[225].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
+        let __v_5: G = G::from_u64(0);
+        let __v_6: G = G::from_u64(1);
+        let __v_7: G = G::from_u64(1);
+        let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; 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_225] = [__v_5, __v_8];
+        record.function_queries[225].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_314: usize = 1;
-const IN_314: usize = 1;
-const OUT_314: usize = 3;
-fn aiur_fn_314(
-  inp: [G; IN_314],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_314], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = G::from_u64(0);
-    let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[313].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_313] = unsafe { *(result.output.as_ptr() as *const [G; OUT_313]) }; __ret } else { aiur_fn_313(__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(0);
-    let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[313].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_313] = unsafe { *(result.output.as_ptr() as *const [G; OUT_313]) }; __ret } else { aiur_fn_313(__args, record, io_buffer, __cu)? } };
-    let __v_5: G = __r_arr[0];
-    let __v_6: G = __r_arr[1];
-    let __ret: [G; OUT_314] = [__v_2, __v_5, __v_6];
-    record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_315: usize = 16;
-const IN_315: usize = 16;
-const OUT_315: usize = 16;
-fn aiur_fn_315(
-  inp: [G; IN_315],
+const INPUT_SIZE_226: usize = 2;
+const IN_226: usize = 2;
+const OUT_226: usize = 2;
+fn aiur_fn_226(
+  inp: [G; IN_226],
   record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_315], 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 = (__v_0 * __v_8);
-    let __v_17: G = (__v_0 * __v_9);
-    let __v_18: G = (__v_1 * __v_8);
-    let __v_19: G = (__v_17 + __v_18);
-    let __v_20: G = (__v_0 * __v_10);
-    let __v_21: G = (__v_1 * __v_9);
-    let __v_22: G = (__v_2 * __v_8);
-    let __v_23: G = (__v_21 + __v_22);
-    let __v_24: G = (__v_20 + __v_23);
-    let __v_25: G = (__v_0 * __v_11);
-    let __v_26: G = (__v_1 * __v_10);
-    let __v_27: G = (__v_2 * __v_9);
-    let __v_28: G = (__v_3 * __v_8);
-    let __v_29: G = (__v_27 + __v_28);
-    let __v_30: G = (__v_26 + __v_29);
-    let __v_31: G = (__v_25 + __v_30);
-    let __v_32: G = (__v_0 * __v_12);
-    let __v_33: G = (__v_1 * __v_11);
-    let __v_34: G = (__v_2 * __v_10);
-    let __v_35: G = (__v_3 * __v_9);
-    let __v_36: G = (__v_4 * __v_8);
-    let __v_37: G = (__v_35 + __v_36);
-    let __v_38: G = (__v_34 + __v_37);
-    let __v_39: G = (__v_33 + __v_38);
-    let __v_40: G = (__v_32 + __v_39);
-    let __v_41: G = (__v_0 * __v_13);
-    let __v_42: G = (__v_1 * __v_12);
-    let __v_43: G = (__v_2 * __v_11);
-    let __v_44: G = (__v_3 * __v_10);
-    let __v_45: G = (__v_4 * __v_9);
-    let __v_46: G = (__v_5 * __v_8);
-    let __v_47: G = (__v_45 + __v_46);
-    let __v_48: G = (__v_44 + __v_47);
-    let __v_49: G = (__v_43 + __v_48);
-    let __v_50: G = (__v_42 + __v_49);
-    let __v_51: G = (__v_41 + __v_50);
-    let __v_52: G = (__v_0 * __v_14);
-    let __v_53: G = (__v_1 * __v_13);
-    let __v_54: G = (__v_2 * __v_12);
-    let __v_55: G = (__v_3 * __v_11);
-    let __v_56: G = (__v_4 * __v_10);
-    let __v_57: G = (__v_5 * __v_9);
-    let __v_58: G = (__v_6 * __v_8);
-    let __v_59: G = (__v_57 + __v_58);
-    let __v_60: G = (__v_56 + __v_59);
-    let __v_61: G = (__v_55 + __v_60);
-    let __v_62: G = (__v_54 + __v_61);
-    let __v_63: G = (__v_53 + __v_62);
-    let __v_64: G = (__v_52 + __v_63);
-    let __v_65: G = (__v_0 * __v_15);
-    let __v_66: G = (__v_1 * __v_14);
-    let __v_67: G = (__v_2 * __v_13);
-    let __v_68: G = (__v_3 * __v_12);
-    let __v_69: G = (__v_4 * __v_11);
-    let __v_70: G = (__v_5 * __v_10);
-    let __v_71: G = (__v_6 * __v_9);
-    let __v_72: G = (__v_7 * __v_8);
-    let __v_73: G = (__v_71 + __v_72);
-    let __v_74: G = (__v_70 + __v_73);
-    let __v_75: G = (__v_69 + __v_74);
-    let __v_76: G = (__v_68 + __v_75);
-    let __v_77: G = (__v_67 + __v_76);
-    let __v_78: G = (__v_66 + __v_77);
-    let __v_79: G = (__v_65 + __v_78);
-    let __v_80: G = (__v_1 * __v_15);
-    let __v_81: G = (__v_2 * __v_14);
-    let __v_82: G = (__v_3 * __v_13);
-    let __v_83: G = (__v_4 * __v_12);
-    let __v_84: G = (__v_5 * __v_11);
-    let __v_85: G = (__v_6 * __v_10);
-    let __v_86: G = (__v_7 * __v_9);
-    let __v_87: G = (__v_85 + __v_86);
-    let __v_88: G = (__v_84 + __v_87);
-    let __v_89: G = (__v_83 + __v_88);
-    let __v_90: G = (__v_82 + __v_89);
-    let __v_91: G = (__v_81 + __v_90);
-    let __v_92: G = (__v_80 + __v_91);
-    let __v_93: G = (__v_2 * __v_15);
-    let __v_94: G = (__v_3 * __v_14);
-    let __v_95: G = (__v_4 * __v_13);
-    let __v_96: G = (__v_5 * __v_12);
-    let __v_97: G = (__v_6 * __v_11);
-    let __v_98: G = (__v_7 * __v_10);
-    let __v_99: G = (__v_97 + __v_98);
-    let __v_100: G = (__v_96 + __v_99);
-    let __v_101: G = (__v_95 + __v_100);
-    let __v_102: G = (__v_94 + __v_101);
-    let __v_103: G = (__v_93 + __v_102);
-    let __v_104: G = (__v_3 * __v_15);
-    let __v_105: G = (__v_4 * __v_14);
-    let __v_106: G = (__v_5 * __v_13);
-    let __v_107: G = (__v_6 * __v_12);
-    let __v_108: G = (__v_7 * __v_11);
-    let __v_109: G = (__v_107 + __v_108);
-    let __v_110: G = (__v_106 + __v_109);
-    let __v_111: G = (__v_105 + __v_110);
-    let __v_112: G = (__v_104 + __v_111);
-    let __v_113: G = (__v_4 * __v_15);
-    let __v_114: G = (__v_5 * __v_14);
-    let __v_115: G = (__v_6 * __v_13);
-    let __v_116: G = (__v_7 * __v_12);
-    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_5 * __v_15);
-    let __v_121: G = (__v_6 * __v_14);
-    let __v_122: G = (__v_7 * __v_13);
-    let __v_123: G = (__v_121 + __v_122);
-    let __v_124: G = (__v_120 + __v_123);
-    let __v_125: G = (__v_6 * __v_15);
-    let __v_126: G = (__v_7 * __v_14);
-    let __v_127: G = (__v_125 + __v_126);
-    let __v_128: G = (__v_7 * __v_15);
-    let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_16]; let __cu = true; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } else { aiur_fn_314(__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 = G::from_u64(0);
-    let __v_133: G = if unconstrained { Bytes2::xor(&__v_129, &__v_132) } else { bytes2_xor_value(__v_129, __v_132, record) };
-    let __v_134: G = G::from_u64(0);
-    let __v_135: G = if unconstrained { Bytes2::xor(&__v_130, &__v_134) } else { bytes2_xor_value(__v_130, __v_134, record) };
-    let __v_136: G = G::from_u64(0);
-    let __v_137: G = if unconstrained { Bytes2::xor(&__v_131, &__v_136) } else { bytes2_xor_value(__v_131, __v_136, record) };
-    let __v_138: G = G::from_u64(256);
-    let __v_139: G = (__v_138 * __v_137);
-    let __v_140: G = (__v_135 + __v_139);
-    let __v_141: G = (__v_19 + __v_140);
-    let __v_142: G = G::from_u64(256);
-    let __v_143: G = (__v_142 * __v_135);
-    let __v_144: G = G::from_u64(65536);
-    let __v_145: G = (__v_144 * __v_137);
-    let __v_146: G = (__v_143 + __v_145);
-    let __v_147: G = (__v_133 + __v_146);
-    if (__v_16 != __v_147) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_147.as_canonical_u64() });
-    }
-    let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_141]; let __cu = true; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } else { aiur_fn_314(__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 = G::from_u64(0);
-    let __v_152: G = if unconstrained { Bytes2::xor(&__v_148, &__v_151) } else { bytes2_xor_value(__v_148, __v_151, record) };
-    let __v_153: G = G::from_u64(0);
-    let __v_154: G = if unconstrained { Bytes2::xor(&__v_149, &__v_153) } else { bytes2_xor_value(__v_149, __v_153, record) };
-    let __v_155: G = G::from_u64(0);
-    let __v_156: G = if unconstrained { Bytes2::xor(&__v_150, &__v_155) } else { bytes2_xor_value(__v_150, __v_155, record) };
-    let __v_157: G = G::from_u64(256);
-    let __v_158: G = (__v_157 * __v_156);
-    let __v_159: G = (__v_154 + __v_158);
-    let __v_160: G = (__v_24 + __v_159);
-    let __v_161: G = G::from_u64(256);
-    let __v_162: G = (__v_161 * __v_154);
-    let __v_163: G = G::from_u64(65536);
-    let __v_164: G = (__v_163 * __v_156);
-    let __v_165: G = (__v_162 + __v_164);
-    let __v_166: G = (__v_152 + __v_165);
-    if (__v_141 != __v_166) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_141.as_canonical_u64(), rhs: __v_166.as_canonical_u64() });
-    }
-    let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_160]; let __cu = true; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } else { aiur_fn_314(__args, record, io_buffer, __cu)? } };
-    let __v_167: G = __r_arr[0];
-    let __v_168: G = __r_arr[1];
-    let __v_169: G = __r_arr[2];
-    let __v_170: G = G::from_u64(0);
-    let __v_171: G = if unconstrained { Bytes2::xor(&__v_167, &__v_170) } else { bytes2_xor_value(__v_167, __v_170, record) };
-    let __v_172: G = G::from_u64(0);
-    let __v_173: G = if unconstrained { Bytes2::xor(&__v_168, &__v_172) } else { bytes2_xor_value(__v_168, __v_172, record) };
-    let __v_174: G = G::from_u64(0);
-    let __v_175: G = if unconstrained { Bytes2::xor(&__v_169, &__v_174) } else { bytes2_xor_value(__v_169, __v_174, record) };
-    let __v_176: G = G::from_u64(256);
-    let __v_177: G = (__v_176 * __v_175);
-    let __v_178: G = (__v_173 + __v_177);
-    let __v_179: G = (__v_31 + __v_178);
-    let __v_180: G = G::from_u64(256);
-    let __v_181: G = (__v_180 * __v_173);
-    let __v_182: G = G::from_u64(65536);
-    let __v_183: G = (__v_182 * __v_175);
-    let __v_184: G = (__v_181 + __v_183);
-    let __v_185: G = (__v_171 + __v_184);
-    if (__v_160 != __v_185) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_160.as_canonical_u64(), rhs: __v_185.as_canonical_u64() });
-    }
-    let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_179]; let __cu = true; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } else { aiur_fn_314(__args, record, io_buffer, __cu)? } };
-    let __v_186: G = __r_arr[0];
-    let __v_187: G = __r_arr[1];
-    let __v_188: G = __r_arr[2];
-    let __v_189: G = G::from_u64(0);
-    let __v_190: G = if unconstrained { Bytes2::xor(&__v_186, &__v_189) } else { bytes2_xor_value(__v_186, __v_189, record) };
-    let __v_191: G = G::from_u64(0);
-    let __v_192: G = if unconstrained { Bytes2::xor(&__v_187, &__v_191) } else { bytes2_xor_value(__v_187, __v_191, record) };
-    let __v_193: G = G::from_u64(0);
-    let __v_194: G = if unconstrained { Bytes2::xor(&__v_188, &__v_193) } else { bytes2_xor_value(__v_188, __v_193, record) };
-    let __v_195: G = G::from_u64(256);
-    let __v_196: G = (__v_195 * __v_194);
-    let __v_197: G = (__v_192 + __v_196);
-    let __v_198: G = (__v_40 + __v_197);
-    let __v_199: G = G::from_u64(256);
-    let __v_200: G = (__v_199 * __v_192);
-    let __v_201: G = G::from_u64(65536);
-    let __v_202: G = (__v_201 * __v_194);
-    let __v_203: G = (__v_200 + __v_202);
-    let __v_204: G = (__v_190 + __v_203);
-    if (__v_179 != __v_204) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_179.as_canonical_u64(), rhs: __v_204.as_canonical_u64() });
-    }
-    let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_198]; let __cu = true; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } else { aiur_fn_314(__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 = G::from_u64(0);
-    let __v_209: G = if unconstrained { Bytes2::xor(&__v_205, &__v_208) } else { bytes2_xor_value(__v_205, __v_208, record) };
-    let __v_210: G = G::from_u64(0);
-    let __v_211: G = if unconstrained { Bytes2::xor(&__v_206, &__v_210) } else { bytes2_xor_value(__v_206, __v_210, record) };
-    let __v_212: G = G::from_u64(0);
-    let __v_213: G = if unconstrained { Bytes2::xor(&__v_207, &__v_212) } else { bytes2_xor_value(__v_207, __v_212, record) };
-    let __v_214: G = G::from_u64(256);
-    let __v_215: G = (__v_214 * __v_213);
-    let __v_216: G = (__v_211 + __v_215);
-    let __v_217: G = (__v_51 + __v_216);
-    let __v_218: G = G::from_u64(256);
-    let __v_219: G = (__v_218 * __v_211);
-    let __v_220: G = G::from_u64(65536);
-    let __v_221: G = (__v_220 * __v_213);
-    let __v_222: G = (__v_219 + __v_221);
-    let __v_223: G = (__v_209 + __v_222);
-    if (__v_198 != __v_223) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_198.as_canonical_u64(), rhs: __v_223.as_canonical_u64() });
-    }
-    let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_217]; let __cu = true; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } else { aiur_fn_314(__args, record, io_buffer, __cu)? } };
-    let __v_224: G = __r_arr[0];
-    let __v_225: G = __r_arr[1];
-    let __v_226: G = __r_arr[2];
-    let __v_227: G = G::from_u64(0);
-    let __v_228: G = if unconstrained { Bytes2::xor(&__v_224, &__v_227) } else { bytes2_xor_value(__v_224, __v_227, record) };
-    let __v_229: G = G::from_u64(0);
-    let __v_230: G = if unconstrained { Bytes2::xor(&__v_225, &__v_229) } else { bytes2_xor_value(__v_225, __v_229, record) };
-    let __v_231: G = G::from_u64(0);
-    let __v_232: G = if unconstrained { Bytes2::xor(&__v_226, &__v_231) } else { bytes2_xor_value(__v_226, __v_231, record) };
-    let __v_233: G = G::from_u64(256);
-    let __v_234: G = (__v_233 * __v_232);
-    let __v_235: G = (__v_230 + __v_234);
-    let __v_236: G = (__v_64 + __v_235);
-    let __v_237: G = G::from_u64(256);
-    let __v_238: G = (__v_237 * __v_230);
-    let __v_239: G = G::from_u64(65536);
-    let __v_240: G = (__v_239 * __v_232);
-    let __v_241: G = (__v_238 + __v_240);
-    let __v_242: G = (__v_228 + __v_241);
-    if (__v_217 != __v_242) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_217.as_canonical_u64(), rhs: __v_242.as_canonical_u64() });
-    }
-    let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_236]; let __cu = true; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } else { aiur_fn_314(__args, record, io_buffer, __cu)? } };
-    let __v_243: G = __r_arr[0];
-    let __v_244: G = __r_arr[1];
-    let __v_245: G = __r_arr[2];
-    let __v_246: G = G::from_u64(0);
-    let __v_247: G = if unconstrained { Bytes2::xor(&__v_243, &__v_246) } else { bytes2_xor_value(__v_243, __v_246, record) };
-    let __v_248: G = G::from_u64(0);
-    let __v_249: G = if unconstrained { Bytes2::xor(&__v_244, &__v_248) } else { bytes2_xor_value(__v_244, __v_248, record) };
-    let __v_250: G = G::from_u64(0);
-    let __v_251: G = if unconstrained { Bytes2::xor(&__v_245, &__v_250) } else { bytes2_xor_value(__v_245, __v_250, record) };
-    let __v_252: G = G::from_u64(256);
-    let __v_253: G = (__v_252 * __v_251);
-    let __v_254: G = (__v_249 + __v_253);
-    let __v_255: G = (__v_79 + __v_254);
-    let __v_256: G = G::from_u64(256);
-    let __v_257: G = (__v_256 * __v_249);
-    let __v_258: G = G::from_u64(65536);
-    let __v_259: G = (__v_258 * __v_251);
-    let __v_260: G = (__v_257 + __v_259);
-    let __v_261: G = (__v_247 + __v_260);
-    if (__v_236 != __v_261) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_236.as_canonical_u64(), rhs: __v_261.as_canonical_u64() });
-    }
-    let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_255]; let __cu = true; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } else { aiur_fn_314(__args, record, io_buffer, __cu)? } };
-    let __v_262: G = __r_arr[0];
-    let __v_263: G = __r_arr[1];
-    let __v_264: G = __r_arr[2];
-    let __v_265: G = G::from_u64(0);
-    let __v_266: G = if unconstrained { Bytes2::xor(&__v_262, &__v_265) } else { bytes2_xor_value(__v_262, __v_265, record) };
-    let __v_267: G = G::from_u64(0);
-    let __v_268: G = if unconstrained { Bytes2::xor(&__v_263, &__v_267) } else { bytes2_xor_value(__v_263, __v_267, record) };
-    let __v_269: G = G::from_u64(0);
-    let __v_270: G = if unconstrained { Bytes2::xor(&__v_264, &__v_269) } else { bytes2_xor_value(__v_264, __v_269, record) };
-    let __v_271: G = G::from_u64(256);
-    let __v_272: G = (__v_271 * __v_270);
-    let __v_273: G = (__v_268 + __v_272);
-    let __v_274: G = (__v_92 + __v_273);
-    let __v_275: G = G::from_u64(256);
-    let __v_276: G = (__v_275 * __v_268);
-    let __v_277: G = G::from_u64(65536);
-    let __v_278: G = (__v_277 * __v_270);
-    let __v_279: G = (__v_276 + __v_278);
-    let __v_280: G = (__v_266 + __v_279);
-    if (__v_255 != __v_280) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_255.as_canonical_u64(), rhs: __v_280.as_canonical_u64() });
-    }
-    let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_274]; let __cu = true; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } else { aiur_fn_314(__args, record, io_buffer, __cu)? } };
-    let __v_281: G = __r_arr[0];
-    let __v_282: G = __r_arr[1];
-    let __v_283: G = __r_arr[2];
-    let __v_284: G = G::from_u64(0);
-    let __v_285: G = if unconstrained { Bytes2::xor(&__v_281, &__v_284) } else { bytes2_xor_value(__v_281, __v_284, record) };
-    let __v_286: G = G::from_u64(0);
-    let __v_287: G = if unconstrained { Bytes2::xor(&__v_282, &__v_286) } else { bytes2_xor_value(__v_282, __v_286, record) };
-    let __v_288: G = G::from_u64(0);
-    let __v_289: G = if unconstrained { Bytes2::xor(&__v_283, &__v_288) } else { bytes2_xor_value(__v_283, __v_288, record) };
-    let __v_290: G = G::from_u64(256);
-    let __v_291: G = (__v_290 * __v_289);
-    let __v_292: G = (__v_287 + __v_291);
-    let __v_293: G = (__v_103 + __v_292);
-    let __v_294: G = G::from_u64(256);
-    let __v_295: G = (__v_294 * __v_287);
-    let __v_296: G = G::from_u64(65536);
-    let __v_297: G = (__v_296 * __v_289);
-    let __v_298: G = (__v_295 + __v_297);
-    let __v_299: G = (__v_285 + __v_298);
-    if (__v_274 != __v_299) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_274.as_canonical_u64(), rhs: __v_299.as_canonical_u64() });
-    }
-    let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_293]; let __cu = true; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } else { aiur_fn_314(__args, record, io_buffer, __cu)? } };
-    let __v_300: G = __r_arr[0];
-    let __v_301: G = __r_arr[1];
-    let __v_302: G = __r_arr[2];
-    let __v_303: G = G::from_u64(0);
-    let __v_304: G = if unconstrained { Bytes2::xor(&__v_300, &__v_303) } else { bytes2_xor_value(__v_300, __v_303, record) };
-    let __v_305: G = G::from_u64(0);
-    let __v_306: G = if unconstrained { Bytes2::xor(&__v_301, &__v_305) } else { bytes2_xor_value(__v_301, __v_305, record) };
-    let __v_307: G = G::from_u64(0);
-    let __v_308: G = if unconstrained { Bytes2::xor(&__v_302, &__v_307) } else { bytes2_xor_value(__v_302, __v_307, record) };
-    let __v_309: G = G::from_u64(256);
-    let __v_310: G = (__v_309 * __v_308);
-    let __v_311: G = (__v_306 + __v_310);
-    let __v_312: G = (__v_112 + __v_311);
-    let __v_313: G = G::from_u64(256);
-    let __v_314: G = (__v_313 * __v_306);
-    let __v_315: G = G::from_u64(65536);
-    let __v_316: G = (__v_315 * __v_308);
-    let __v_317: G = (__v_314 + __v_316);
-    let __v_318: G = (__v_304 + __v_317);
-    if (__v_293 != __v_318) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_293.as_canonical_u64(), rhs: __v_318.as_canonical_u64() });
-    }
-    let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_312]; let __cu = true; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } else { aiur_fn_314(__args, record, io_buffer, __cu)? } };
-    let __v_319: G = __r_arr[0];
-    let __v_320: G = __r_arr[1];
-    let __v_321: G = __r_arr[2];
-    let __v_322: G = G::from_u64(0);
-    let __v_323: G = if unconstrained { Bytes2::xor(&__v_319, &__v_322) } else { bytes2_xor_value(__v_319, __v_322, record) };
-    let __v_324: G = G::from_u64(0);
-    let __v_325: G = if unconstrained { Bytes2::xor(&__v_320, &__v_324) } else { bytes2_xor_value(__v_320, __v_324, record) };
-    let __v_326: G = G::from_u64(0);
-    let __v_327: G = if unconstrained { Bytes2::xor(&__v_321, &__v_326) } else { bytes2_xor_value(__v_321, __v_326, record) };
-    let __v_328: G = G::from_u64(256);
-    let __v_329: G = (__v_328 * __v_327);
-    let __v_330: G = (__v_325 + __v_329);
-    let __v_331: G = (__v_119 + __v_330);
-    let __v_332: G = G::from_u64(256);
-    let __v_333: G = (__v_332 * __v_325);
-    let __v_334: G = G::from_u64(65536);
-    let __v_335: G = (__v_334 * __v_327);
-    let __v_336: G = (__v_333 + __v_335);
-    let __v_337: G = (__v_323 + __v_336);
-    if (__v_312 != __v_337) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_312.as_canonical_u64(), rhs: __v_337.as_canonical_u64() });
-    }
-    let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_331]; let __cu = true; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } else { aiur_fn_314(__args, record, io_buffer, __cu)? } };
-    let __v_338: G = __r_arr[0];
-    let __v_339: G = __r_arr[1];
-    let __v_340: G = __r_arr[2];
-    let __v_341: G = G::from_u64(0);
-    let __v_342: G = if unconstrained { Bytes2::xor(&__v_338, &__v_341) } else { bytes2_xor_value(__v_338, __v_341, record) };
-    let __v_343: G = G::from_u64(0);
-    let __v_344: G = if unconstrained { Bytes2::xor(&__v_339, &__v_343) } else { bytes2_xor_value(__v_339, __v_343, record) };
-    let __v_345: G = G::from_u64(0);
-    let __v_346: G = if unconstrained { Bytes2::xor(&__v_340, &__v_345) } else { bytes2_xor_value(__v_340, __v_345, record) };
-    let __v_347: G = G::from_u64(256);
-    let __v_348: G = (__v_347 * __v_346);
-    let __v_349: G = (__v_344 + __v_348);
-    let __v_350: G = (__v_124 + __v_349);
-    let __v_351: G = G::from_u64(256);
-    let __v_352: G = (__v_351 * __v_344);
-    let __v_353: G = G::from_u64(65536);
-    let __v_354: G = (__v_353 * __v_346);
-    let __v_355: G = (__v_352 + __v_354);
-    let __v_356: G = (__v_342 + __v_355);
-    if (__v_331 != __v_356) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_331.as_canonical_u64(), rhs: __v_356.as_canonical_u64() });
-    }
-    let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_350]; let __cu = true; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } else { aiur_fn_314(__args, record, io_buffer, __cu)? } };
-    let __v_357: G = __r_arr[0];
-    let __v_358: G = __r_arr[1];
-    let __v_359: G = __r_arr[2];
-    let __v_360: G = G::from_u64(0);
-    let __v_361: G = if unconstrained { Bytes2::xor(&__v_357, &__v_360) } else { bytes2_xor_value(__v_357, __v_360, record) };
-    let __v_362: G = G::from_u64(0);
-    let __v_363: G = if unconstrained { Bytes2::xor(&__v_358, &__v_362) } else { bytes2_xor_value(__v_358, __v_362, record) };
-    let __v_364: G = G::from_u64(0);
-    let __v_365: G = if unconstrained { Bytes2::xor(&__v_359, &__v_364) } else { bytes2_xor_value(__v_359, __v_364, record) };
-    let __v_366: G = G::from_u64(256);
-    let __v_367: G = (__v_366 * __v_365);
-    let __v_368: G = (__v_363 + __v_367);
-    let __v_369: G = (__v_127 + __v_368);
-    let __v_370: G = G::from_u64(256);
-    let __v_371: G = (__v_370 * __v_363);
-    let __v_372: G = G::from_u64(65536);
-    let __v_373: G = (__v_372 * __v_365);
-    let __v_374: G = (__v_371 + __v_373);
-    let __v_375: G = (__v_361 + __v_374);
-    if (__v_350 != __v_375) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_350.as_canonical_u64(), rhs: __v_375.as_canonical_u64() });
-    }
-    let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_369]; let __cu = true; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } else { aiur_fn_314(__args, record, io_buffer, __cu)? } };
-    let __v_376: G = __r_arr[0];
-    let __v_377: G = __r_arr[1];
-    let __v_378: G = __r_arr[2];
-    let __v_379: G = G::from_u64(0);
-    let __v_380: G = if unconstrained { Bytes2::xor(&__v_376, &__v_379) } else { bytes2_xor_value(__v_376, __v_379, record) };
-    let __v_381: G = G::from_u64(0);
-    let __v_382: G = if unconstrained { Bytes2::xor(&__v_377, &__v_381) } else { bytes2_xor_value(__v_377, __v_381, record) };
-    let __v_383: G = G::from_u64(0);
-    let __v_384: G = if unconstrained { Bytes2::xor(&__v_378, &__v_383) } else { bytes2_xor_value(__v_378, __v_383, record) };
-    let __v_385: G = G::from_u64(256);
-    let __v_386: G = (__v_385 * __v_384);
-    let __v_387: G = (__v_382 + __v_386);
-    let __v_388: G = (__v_128 + __v_387);
-    let __v_389: G = G::from_u64(256);
-    let __v_390: G = (__v_389 * __v_382);
-    let __v_391: G = G::from_u64(65536);
-    let __v_392: G = (__v_391 * __v_384);
-    let __v_393: G = (__v_390 + __v_392);
-    let __v_394: G = (__v_380 + __v_393);
-    if (__v_369 != __v_394) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_369.as_canonical_u64(), rhs: __v_394.as_canonical_u64() });
-    }
-    let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_388]; let __cu = true; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } else { aiur_fn_314(__args, record, io_buffer, __cu)? } };
-    let __v_395: G = __r_arr[0];
-    let __v_396: G = __r_arr[1];
-    let __v_397: G = __r_arr[2];
-    let __v_398: G = G::from_u64(0);
-    let __v_399: G = if unconstrained { Bytes2::xor(&__v_395, &__v_398) } else { bytes2_xor_value(__v_395, __v_398, record) };
-    let __v_400: G = G::from_u64(0);
-    let __v_401: G = if unconstrained { Bytes2::xor(&__v_396, &__v_400) } else { bytes2_xor_value(__v_396, __v_400, record) };
-    let __v_402: G = G::from_u64(0);
-    let __v_403: G = if unconstrained { Bytes2::xor(&__v_397, &__v_402) } else { bytes2_xor_value(__v_397, __v_402, record) };
-    let __v_404: G = G::from_u64(256);
-    let __v_405: G = (__v_404 * __v_403);
-    let __v_406: G = (__v_401 + __v_405);
-    let __v_407: G = G::from_u64(256);
-    let __v_408: G = (__v_407 * __v_401);
-    let __v_409: G = G::from_u64(65536);
-    let __v_410: G = (__v_409 * __v_403);
-    let __v_411: G = (__v_408 + __v_410);
-    let __v_412: G = (__v_399 + __v_411);
-    if (__v_388 != __v_412) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_388.as_canonical_u64(), rhs: __v_412.as_canonical_u64() });
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_226], 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() {
+      2u64 => {
+        let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[139].get_mut(&__args[..]) { 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_6: G = __r_arr[0];
+        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_7: G = __r_arr[0];
+        match __v_7.as_canonical_u64() {
+          1u64 => {
+            let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[225].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_225] = unsafe { *(result.output.as_ptr() as *const [G; OUT_225]) }; __ret } else { aiur_fn_225(__args, record, io_buffer, __cu)? } };
+            let __v_8: G = __r_arr[0];
+            let __v_9: G = __r_arr[1];
+            match __v_8.as_canonical_u64() {
+              1u64 => {
+                let __v_10: G = G::from_u64(1);
+                let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { 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_11: G = __r_arr[0];
+                let __ret: [G; OUT_226] = [__v_10, __v_11];
+                record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                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 = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; 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_226] = [__v_10, __v_13];
+                record.function_queries[226].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 = G::from_u64(1);
+            let __v_11: G = { let __values: [G; 10] = [__v_9, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10]; 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_226] = [__v_8, __v_11];
+            record.function_queries[226].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(1);
+        let __v_9: G = { let __values: [G; 10] = [__v_7, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8]; 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_226] = [__v_6, __v_9];
+        record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
     }
-    let __ret: [G; OUT_315] = [__v_133, __v_152, __v_171, __v_190, __v_209, __v_228, __v_247, __v_266, __v_285, __v_304, __v_323, __v_342, __v_361, __v_380, __v_399, __v_406];
-    record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_316: usize = 2;
-const IN_316: usize = 2;
-const OUT_316: usize = 1;
-fn aiur_fn_316(
-  inp: [G; IN_316],
+const INPUT_SIZE_227: usize = 1;
+const IN_227: usize = 1;
+const OUT_227: usize = 1;
+fn aiur_fn_227(
+  inp: [G; IN_227],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_316], ExecError> {
+) -> Result<[G; OUT_227], 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; 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 __v_5: G = G::from_u64(0);
-    let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_0, __v_1, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = unsafe { *(result.output.as_ptr() as *const [G; OUT_317]) }; __ret } else { aiur_fn_317(__args, record, io_buffer, __cu)? } };
-    let __v_6: G = __r_arr[0];
-    let __ret: [G; OUT_316] = [__v_6];
-    record.function_queries[316].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __v_1: G = G::from_u64(7);
+    let __v_2: G = G::from_u64(0);
+    let __v_3: G = G::from_u64(0);
+    let __v_4: G = { let __values: [G; 4] = [__v_1, __v_2, __v_0, __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_227] = [__v_4];
+    record.function_queries[227].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_317: usize = 4;
-const IN_317: usize = 4;
-const OUT_317: usize = 1;
-fn aiur_fn_317(
-  inp: [G; IN_317],
+const INPUT_SIZE_228: usize = 2;
+const IN_228: usize = 2;
+const OUT_228: usize = 1;
+fn aiur_fn_228(
+  inp: [G; IN_228],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_317], ExecError> {
+) -> Result<[G; OUT_228], 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; 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_4: G = __loaded[0];
-    let __v_5: G = __loaded[1];
-    let __v_6: G = __loaded[2];
-    let __v_7: G = __loaded[3];
-    let __v_8: G = __loaded[4];
-    let __v_9: G = __loaded[5];
-    let __v_10: G = __loaded[6];
-    let __v_11: G = __loaded[7];
-    let __v_12: G = __loaded[8];
-    let __v_13: G = __loaded[9];
-    match __v_4.as_canonical_u64() {
+    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_317] = [__v_2];
-        record.function_queries[317].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_228] = [__v_0];
+        record.function_queries[228].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        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 = 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(1);
-        let __v_23: G = G::from_u64(1);
-        let __v_24: G = { let __values: [G; 10] = [__v_22, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; 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_318] = { let __args: [G; IN_318] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_1, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[318].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_318] = unsafe { *(result.output.as_ptr() as *const [G; OUT_318]) }; __ret } else { aiur_fn_318(__args, record, io_buffer, __cu)? } };
-        let __v_25: G = __r_arr[0];
-        let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_25, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = unsafe { *(result.output.as_ptr() as *const [G; OUT_319]) }; __ret } else { aiur_fn_319(__args, record, io_buffer, __cu)? } };
-        let __v_26: G = __r_arr[0];
-        let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_2, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } else { aiur_fn_306(__args, record, io_buffer, __cu)? } };
-        let __v_27: G = __r_arr[0];
-        let __v_28: G = G::from_u64(1);
-        let __v_29: G = (__v_3 + __v_28);
-        let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_13, __v_1, __v_27, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = unsafe { *(result.output.as_ptr() as *const [G; OUT_317]) }; __ret } else { aiur_fn_317(__args, record, io_buffer, __cu)? } };
-        let __v_30: G = __r_arr[0];
-        let __ret: [G; OUT_317] = [__v_30];
-        record.function_queries[317].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __v_5: G = G::from_u64(3);
+        let __v_6: G = G::from_u64(0);
+        let __v_7: G = { let __values: [G; 4] = [__v_5, __v_0, __v_3, __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 __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_7, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } };
+        let __v_8: G = __r_arr[0];
+        let __ret: [G; OUT_228] = [__v_8];
+        record.function_queries[228].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_318: usize = 18;
-const IN_318: usize = 18;
-const OUT_318: usize = 1;
-fn aiur_fn_318(
-  inp: [G; IN_318],
+const INPUT_SIZE_229: usize = 3;
+const IN_229: usize = 3;
+const OUT_229: usize = 2;
+fn aiur_fn_229(
+  inp: [G; IN_229],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_318], ExecError> {
+) -> Result<[G; OUT_229], 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 __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).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_18: G = __loaded[0];
-    let __v_19: G = __loaded[1];
-    let __v_20: G = __loaded[2];
-    let __v_21: G = __loaded[3];
-    let __v_22: G = __loaded[4];
-    let __v_23: G = __loaded[5];
-    let __v_24: G = __loaded[6];
-    let __v_25: G = __loaded[7];
-    let __v_26: G = __loaded[8];
-    let __v_27: G = __loaded[9];
-    match __v_18.as_canonical_u64() {
+    let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[141].get_mut(&__args[..]) { 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_3: G = __r_arr[0];
+    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_4: G = __r_arr[0];
+    match __v_4.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__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[2].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
-        let __v_28: G = __r_arr[0];
-        match __v_28.as_canonical_u64() {
+        let __v_5: G = G::from_u64(1);
+        let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[109].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_109] = unsafe { *(result.output.as_ptr() as *const [G; OUT_109]) }; __ret } else { aiur_fn_109(__args, record, io_buffer, __cu)? } };
+        let __v_6: G = __r_arr[0];
+        let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { 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_7: G = __r_arr[0];
+        let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } else { aiur_fn_227(__args, record, io_buffer, __cu)? } };
+        let __v_8: G = __r_arr[0];
+        let __ret: [G; OUT_229] = [__v_5, __v_8];
+        record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[142].get_mut(&__args[..]) { 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_5: G = __r_arr[0];
+        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_6: G = __r_arr[0];
+        match __v_6.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_318] = [__v_17];
-            record.function_queries[318].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __v_7: G = G::from_u64(1);
+            let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } };
+            let __v_8: G = __r_arr[0];
+            let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { 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_9: G = __r_arr[0];
+            let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } else { aiur_fn_227(__args, record, io_buffer, __cu)? } };
+            let __v_10: G = __r_arr[0];
+            let __ret: [G; OUT_229] = [__v_7, __v_10];
+            record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
+          _ => {
+            let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[143].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_143] = unsafe { *(result.output.as_ptr() as *const [G; OUT_143]) }; __ret } else { aiur_fn_143(__args, record, io_buffer, __cu)? } };
+            let __v_7: G = __r_arr[0];
+            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_8: G = __r_arr[0];
+            match __v_8.as_canonical_u64() {
+              1u64 => {
+                let __v_9: G = G::from_u64(1);
+                let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { 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_10: G = __r_arr[0];
+                let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { 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_11: G = __r_arr[0];
+                let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } else { aiur_fn_227(__args, record, io_buffer, __cu)? } };
+                let __v_12: G = __r_arr[0];
+                let __ret: [G; OUT_229] = [__v_9, __v_12];
+                record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } else { aiur_fn_147(__args, record, io_buffer, __cu)? } };
+                let __v_9: G = __r_arr[0];
+                let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_10: G = __r_arr[0];
+                match __v_10.as_canonical_u64() {
+                  1u64 => {
+                    let __v_11: G = G::from_u64(1);
+                    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { 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_12: G = __r_arr[0];
+                    let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { 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_13: G = __r_arr[0];
+                    let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } else { aiur_fn_227(__args, record, io_buffer, __cu)? } };
+                    let __v_14: G = __r_arr[0];
+                    let __ret: [G; OUT_229] = [__v_11, __v_14];
+                    record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
+                  },
+                  _ => {
+                    let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { 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_11: G = __r_arr[0];
+                    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_12: G = __r_arr[0];
+                    match __v_12.as_canonical_u64() {
+                      1u64 => {
+                        let __v_13: G = G::from_u64(1);
+                        let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { 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_14: G = __r_arr[0];
+                        let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { 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_15: G = __r_arr[0];
+                        let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } else { aiur_fn_227(__args, record, io_buffer, __cu)? } };
+                        let __v_16: G = __r_arr[0];
+                        let __ret: [G; OUT_229] = [__v_13, __v_16];
+                        record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        return Ok(__ret);
+                      },
+                      _ => {
+                        let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[145].get_mut(&__args[..]) { 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_13: G = __r_arr[0];
+                        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_14: G = __r_arr[0];
+                        match __v_14.as_canonical_u64() {
+                          1u64 => {
+                            let __v_15: G = G::from_u64(1);
+                            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 !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_16: G = __r_arr[0];
+                            let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { 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_17: G = __r_arr[0];
+                            let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } else { aiur_fn_227(__args, record, io_buffer, __cu)? } };
+                            let __v_18: G = __r_arr[0];
+                            let __ret: [G; OUT_229] = [__v_15, __v_18];
+                            record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            return Ok(__ret);
+                          },
+                          _ => {
+                            let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[144].get_mut(&__args[..]) { 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_15: G = __r_arr[0];
+                            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_16: G = __r_arr[0];
+                            match __v_16.as_canonical_u64() {
+                              1u64 => {
+                                let __v_17: G = G::from_u64(1);
+                                let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { 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_18: G = __r_arr[0];
+                                let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { 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_19: G = __r_arr[0];
+                                let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } else { aiur_fn_227(__args, record, io_buffer, __cu)? } };
+                                let __v_20: G = __r_arr[0];
+                                let __ret: [G; OUT_229] = [__v_17, __v_20];
+                                record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                return Ok(__ret);
+                              },
+                              _ => {
+                                let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { 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_17: G = __r_arr[0];
+                                let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_18: G = __r_arr[0];
+                                match __v_18.as_canonical_u64() {
+                                  1u64 => {
+                                    let __v_19: G = G::from_u64(1);
+                                    let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { 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_20: G = __r_arr[0];
+                                    let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { 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_21: G = __r_arr[0];
+                                    let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } else { aiur_fn_227(__args, record, io_buffer, __cu)? } };
+                                    let __v_22: G = __r_arr[0];
+                                    let __ret: [G; OUT_229] = [__v_19, __v_22];
+                                    record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                    return Ok(__ret);
+                                  },
+                                  _ => {
+                                    let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { 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_19: G = __r_arr[0];
+                                    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_20: G = __r_arr[0];
+                                    match __v_20.as_canonical_u64() {
+                                      1u64 => {
+                                        let __v_21: G = G::from_u64(1);
+                                        let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[134].get_mut(&__args[..]) { 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_22: G = __r_arr[0];
+                                        let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { 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_23: G = __r_arr[0];
+                                        let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } else { aiur_fn_227(__args, record, io_buffer, __cu)? } };
+                                        let __v_24: G = __r_arr[0];
+                                        let __ret: [G; OUT_229] = [__v_21, __v_24];
+                                        record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                        return Ok(__ret);
+                                      },
+                                      _ => {
+                                        let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { 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_21: G = __r_arr[0];
+                                        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_22: G = __r_arr[0];
+                                        match __v_22.as_canonical_u64() {
+                                          1u64 => {
+                                            let __v_23: G = G::from_u64(1);
+                                            let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[135].get_mut(&__args[..]) { 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_24: G = __r_arr[0];
+                                            let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { 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_25: G = __r_arr[0];
+                                            let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } else { aiur_fn_227(__args, record, io_buffer, __cu)? } };
+                                            let __v_26: G = __r_arr[0];
+                                            let __ret: [G; OUT_229] = [__v_23, __v_26];
+                                            record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                            return Ok(__ret);
+                                          },
+                                          _ => {
+                                            let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[151].get_mut(&__args[..]) { 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_23: G = __r_arr[0];
+                                            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_24: G = __r_arr[0];
+                                            match __v_24.as_canonical_u64() {
+                                              1u64 => {
+                                                let __v_25: G = G::from_u64(1);
+                                                let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[136].get_mut(&__args[..]) { 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_26: G = __r_arr[0];
+                                                let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { 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_27: G = __r_arr[0];
+                                                let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } else { aiur_fn_227(__args, record, io_buffer, __cu)? } };
+                                                let __v_28: G = __r_arr[0];
+                                                let __ret: [G; OUT_229] = [__v_25, __v_28];
+                                                record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                return Ok(__ret);
+                                              },
+                                              _ => {
+                                                let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_26: G = __r_arr[0];
+                                                match __v_26.as_canonical_u64() {
+                                                  1u64 => {
+                                                    let __v_27: G = G::from_u64(1);
+                                                    let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[137].get_mut(&__args[..]) { 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_28: G = __r_arr[0];
+                                                    let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { 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_29: G = __r_arr[0];
+                                                    let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } else { aiur_fn_227(__args, record, io_buffer, __cu)? } };
+                                                    let __v_30: G = __r_arr[0];
+                                                    let __ret: [G; OUT_229] = [__v_27, __v_30];
+                                                    record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                    return Ok(__ret);
+                                                  },
+                                                  _ => {
+                                                    let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[153].get_mut(&__args[..]) { 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_27: G = __r_arr[0];
+                                                    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_28: G = __r_arr[0];
+                                                    match __v_28.as_canonical_u64() {
+                                                      1u64 => {
+                                                        let __v_29: G = G::from_u64(1);
+                                                        let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } };
+                                                        let __v_30: G = __r_arr[0];
+                                                        let __r_arr: [G; OUT_181] = { let __args: [G; IN_181] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[181].get_mut(&__args[..]) { 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_31: G = __r_arr[0];
+                                                        let __ret: [G; OUT_229] = [__v_29, __v_31];
+                                                        record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                        return Ok(__ret);
+                                                      },
+                                                      _ => {
+                                                        let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[154].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_30: G = __r_arr[0];
+                                                        match __v_30.as_canonical_u64() {
+                                                          1u64 => {
+                                                            let __v_31: G = G::from_u64(1);
+                                                            let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { 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_32: G = __r_arr[0];
+                                                            let __r_arr: [G; OUT_181] = { let __args: [G; IN_181] = [__v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[181].get_mut(&__args[..]) { 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_33: G = __r_arr[0];
+                                                            let __ret: [G; OUT_229] = [__v_31, __v_33];
+                                                            record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                            return Ok(__ret);
+                                                          },
+                                                          _ => {
+                                                            let __v_31: G = G::from_u64(0);
+                                                            let __v_32: G = G::from_u64(0);
+                                                            let __v_33: G = G::from_u64(0);
+                                                            let __v_34: G = G::from_u64(0);
+                                                            let __v_35: G = { let __values: [G; 4] = [__v_32, __v_33, __v_34, __v_34]; 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_229] = [__v_31, __v_35];
+                                                            record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                            return Ok(__ret);
+                                                          },
+                                                        }
+                                                      },
+                                                    }
+                                                  },
+                                                }
+                                              },
+                                            }
+                                          },
+                                        }
+                                      },
+                                    }
+                                  },
+                                }
+                              },
+                            }
+                          },
+                        }
+                      },
+                    }
+                  },
+                }
+              },
+            }
+          },
+        }
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_230: usize = 2;
+const IN_230: usize = 2;
+const OUT_230: usize = 3;
+fn aiur_fn_230(
+  inp: [G; IN_230],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_230], 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() {
+      2u64 => {
+        let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[141].get_mut(&__args[..]) { 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];
+        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_7: G = __r_arr[0];
+        match __v_7.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_798] = { let __args: [G; IN_798] = [__v_17, __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[798].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_798] = unsafe { *(result.output.as_ptr() as *const [G; OUT_798]) }; __ret } else { aiur_fn_798(__args, record, io_buffer, __cu)? } };
-            let __v_29: G = __r_arr[0];
-            let __ret: [G; OUT_318] = [__v_29];
-            record.function_queries[318].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __v_8: G = G::from_u64(0);
+            let __v_9: G = G::from_u64(1);
+            let __v_10: G = G::from_u64(1);
+            let __v_11: G = { let __values: [G; 10] = [__v_9, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10]; 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_230] = [__v_8, __v_0, __v_11];
+            record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_28.as_canonical_u64()));
+            let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } else { aiur_fn_711(__args, record, io_buffer, __cu)? } };
+            let __v_8: G = __r_arr[0];
+            let __v_9: G = G::from_u64(2);
+            let __v_10: G = (__v_8 - __v_9);
+            match __v_10.as_canonical_u64() {
+              0u64 => {
+                let __v_11: G = G::from_u64(0);
+                let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__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_713] = { let __args: [G; IN_713] = [__v_1, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } };
+                let __v_14: 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_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).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_15: G = __loaded[0];
+                let __v_16: G = __loaded[1];
+                let __v_17: G = __loaded[2];
+                let __v_18: G = __loaded[3];
+                match __v_15.as_canonical_u64() {
+                  7u64 => {
+                    match __v_16.as_canonical_u64() {
+                      0u64 => {
+                        let __v_19: G = G::from_u64(1);
+                        let __ret: [G; OUT_230] = [__v_19, __v_12, __v_17];
+                        record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        return Ok(__ret);
+                      },
+                      _ => {
+                        let __v_19: G = G::from_u64(0);
+                        let __v_20: G = G::from_u64(1);
+                        let __v_21: G = G::from_u64(1);
+                        let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; 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_230] = [__v_19, __v_0, __v_22];
+                        record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        return Ok(__ret);
+                      },
+                    }
+                  },
+                  _ => {
+                    let __v_19: G = G::from_u64(0);
+                    let __v_20: G = G::from_u64(1);
+                    let __v_21: G = G::from_u64(1);
+                    let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; 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_230] = [__v_19, __v_0, __v_22];
+                    record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
+                  },
+                }
+              },
+              _ => {
+                let __v_11: G = G::from_u64(0);
+                let __v_12: G = G::from_u64(1);
+                let __v_13: G = G::from_u64(1);
+                let __v_14: G = { let __values: [G; 10] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __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_230] = [__v_11, __v_0, __v_14];
+                record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+            }
           },
         }
       },
-      0u64 => {
-        let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = unsafe { *(result.output.as_ptr() as *const [G; OUT_315]) }; __ret } else { aiur_fn_315(__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 __v_39: G = __r_arr[11];
-        let __v_40: G = __r_arr[12];
-        let __v_41: G = __r_arr[13];
-        let __v_42: G = __r_arr[14];
-        let __v_43: G = __r_arr[15];
-        let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __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[10].get_mut(&__args[..]) { 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_44: G = __r_arr[0];
-        let __v_45: G = __r_arr[1];
-        let __v_46: G = __r_arr[2];
-        let __v_47: G = __r_arr[3];
-        let __v_48: G = __r_arr[4];
-        let __v_49: G = __r_arr[5];
-        let __v_50: G = __r_arr[6];
-        let __v_51: G = __r_arr[7];
-        let __v_52: G = __r_arr[8];
-        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 __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59]; let __cu = unconstrained; if let Some(result) = record.function_queries[10].get_mut(&__args[..]) { 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_60: G = __r_arr[0];
-        let __v_61: G = __r_arr[1];
-        let __v_62: G = __r_arr[2];
-        let __v_63: G = __r_arr[3];
-        let __v_64: G = __r_arr[4];
-        let __v_65: G = __r_arr[5];
-        let __v_66: G = __r_arr[6];
-        let __v_67: G = __r_arr[7];
-        let __v_68: G = __r_arr[8];
-        let __r_arr: [G; OUT_798] = { let __args: [G; IN_798] = [__v_17, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[798].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_798] = unsafe { *(result.output.as_ptr() as *const [G; OUT_798]) }; __ret } else { aiur_fn_798(__args, record, io_buffer, __cu)? } };
-        let __v_69: G = __r_arr[0];
-        let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_27, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_69]; let __cu = unconstrained; if let Some(result) = record.function_queries[318].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_318] = unsafe { *(result.output.as_ptr() as *const [G; OUT_318]) }; __ret } else { aiur_fn_318(__args, record, io_buffer, __cu)? } };
-        let __v_70: G = __r_arr[0];
-        let __ret: [G; OUT_318] = [__v_70];
-        record.function_queries[318].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+      _ => {
+        let __v_6: G = G::from_u64(0);
+        let __v_7: G = G::from_u64(1);
+        let __v_8: G = G::from_u64(1);
+        let __v_9: G = { let __values: [G; 10] = [__v_7, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8]; 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_230] = [__v_6, __v_0, __v_9];
+        record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_231: usize = 2;
+const IN_231: usize = 2;
+const OUT_231: usize = 1;
+fn aiur_fn_231(
+  inp: [G; IN_231],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_231], 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(0);
+    let __v_3: G = G::from_u64(1);
+    let __v_4: G = G::from_u64(0);
+    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(1);
+    let __v_12: G = G::from_u64(1);
+    let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; 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_14: G = { let __values: [G; 10] = [__v_2, __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 __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_1, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } };
+    let __v_15: G = __r_arr[0];
+    let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { 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_16: G = __r_arr[0];
+    let __v_17: G = G::from_u64(2);
+    let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[139].get_mut(&__args[..]) { 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_18: G = __r_arr[0];
+    let __v_19: G = G::from_u64(1);
+    let __v_20: G = G::from_u64(1);
+    let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __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 = G::from_u64(0);
+    let __v_23: G = { let __values: [G; 4] = [__v_17, __v_18, __v_21, __v_22]; 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_124] = { let __args: [G; IN_124] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { 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_24: G = __r_arr[0];
+    match __v_24.as_canonical_u64() {
+      1u64 => {
+        let __v_25: G = G::from_u64(3);
+        let __v_26: G = G::from_u64(0);
+        let __v_27: G = { let __values: [G; 4] = [__v_25, __v_23, __v_0, __v_26]; 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_231] = [__v_27];
+        record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __v_25: G = G::from_u64(2);
+        let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[141].get_mut(&__args[..]) { 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_26: G = __r_arr[0];
+        let __v_27: G = G::from_u64(1);
+        let __v_28: G = G::from_u64(1);
+        let __v_29: G = { let __values: [G; 3] = [__v_27, __v_28, __v_28]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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 = G::from_u64(0);
+        let __v_31: G = { let __values: [G; 4] = [__v_25, __v_26, __v_29, __v_30]; 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_32: G = G::from_u64(7);
+        let __v_33: G = G::from_u64(0);
+        let __v_34: G = G::from_u64(0);
+        let __v_35: G = { let __values: [G; 4] = [__v_32, __v_33, __v_16, __v_34]; 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_36: G = G::from_u64(3);
+        let __v_37: G = G::from_u64(3);
+        let __v_38: G = G::from_u64(0);
+        let __v_39: G = { let __values: [G; 4] = [__v_37, __v_31, __v_0, __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 __v_40: G = G::from_u64(0);
+        let __v_41: G = { let __values: [G; 4] = [__v_36, __v_39, __v_35, __v_40]; 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_42: G = G::from_u64(3);
+        let __v_43: G = G::from_u64(0);
+        let __v_44: G = { let __values: [G; 4] = [__v_42, __v_23, __v_41, __v_43]; 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_231] = [__v_44];
+        record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_232: usize = 1;
+const IN_232: usize = 1;
+const OUT_232: usize = 1;
+fn aiur_fn_232(
+  inp: [G; IN_232],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_232], 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() {
+      7u64 => {
+        let __ret: [G; OUT_232] = [__v_0];
+        record.function_queries[232].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_18.as_canonical_u64()));
+        let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[106].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_106] = unsafe { *(result.output.as_ptr() as *const [G; OUT_106]) }; __ret } else { aiur_fn_106(__args, record, io_buffer, __cu)? } };
+        let __v_5: G = __r_arr[0];
+        let __v_6: G = __r_arr[1];
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; 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: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].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];
+        match __v_7.as_canonical_u64() {
+          2u64 => {
+            let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_230] = unsafe { *(result.output.as_ptr() as *const [G; OUT_230]) }; __ret } else { aiur_fn_230(__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];
+            match __v_11.as_canonical_u64() {
+              1u64 => {
+                let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { 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_14: G = __r_arr[0];
+                let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { 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_15: G = __r_arr[0];
+                match __v_15.as_canonical_u64() {
+                  1u64 => {
+                    let __ret: [G; OUT_232] = [__v_0];
+                    record.function_queries[232].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
+                  },
+                  _ => {
+                    let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_12, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[231].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_231] = unsafe { *(result.output.as_ptr() as *const [G; OUT_231]) }; __ret } else { aiur_fn_231(__args, record, io_buffer, __cu)? } };
+                    let __v_16: G = __r_arr[0];
+                    let __ret: [G; OUT_232] = [__v_16];
+                    record.function_queries[232].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
+                  },
+                }
+              },
+              _ => {
+                let __ret: [G; OUT_232] = [__v_0];
+                record.function_queries[232].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+            }
+          },
+          _ => {
+            let __ret: [G; OUT_232] = [__v_0];
+            record.function_queries[232].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+        }
       },
     }
   })
 }
 
-const INPUT_SIZE_319: usize = 2;
-const IN_319: usize = 2;
-const OUT_319: usize = 1;
-fn aiur_fn_319(
-  inp: [G; IN_319],
+const INPUT_SIZE_233: usize = 3;
+const IN_233: usize = 3;
+const OUT_233: usize = 2;
+fn aiur_fn_233(
+  inp: [G; IN_233],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_319], ExecError> {
+) -> Result<[G; OUT_233], 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_319] = [__v_0];
-        record.function_queries[319].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __v_2: G = inp[2];
+    let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { 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_3: G = __r_arr[0];
+    match __v_3.as_canonical_u64() {
+      1u64 => {
+        let __v_4: G = G::from_u64(1);
+        let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } };
+        let __v_5: G = __r_arr[0];
+        let __ret: [G; OUT_233] = [__v_4, __v_5];
+        record.function_queries[233].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 = G::from_u64(0);
-        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_4: G = G::from_u64(2);
+        let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[141].get_mut(&__args[..]) { 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_5: G = __r_arr[0];
+        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 __v_9: G = G::from_u64(0);
-        let __v_10: G = G::from_u64(0);
-        let __v_11: G = { let __values: [G; 10] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_0]; 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_12: G = G::from_u64(1);
-        let __v_13: G = (__v_1 - __v_12);
-        let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_11, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = unsafe { *(result.output.as_ptr() as *const [G; OUT_319]) }; __ret } else { aiur_fn_319(__args, record, io_buffer, __cu)? } };
-        let __v_14: G = __r_arr[0];
-        let __ret: [G; OUT_319] = [__v_14];
-        record.function_queries[319].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __v_10: G = { let __values: [G; 4] = [__v_4, __v_5, __v_8, __v_9]; 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_11: G = G::from_u64(3);
+        let __v_12: G = G::from_u64(3);
+        let __v_13: G = G::from_u64(0);
+        let __v_14: G = { let __values: [G; 4] = [__v_12, __v_10, __v_0, __v_13]; 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_227] = { let __args: [G; IN_227] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } else { aiur_fn_227(__args, record, io_buffer, __cu)? } };
+        let __v_15: G = __r_arr[0];
+        let __v_16: G = G::from_u64(0);
+        let __v_17: G = { let __values: [G; 4] = [__v_11, __v_14, __v_15, __v_16]; 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_18: G = G::from_u64(1);
+        let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_17, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } };
+        let __v_19: G = __r_arr[0];
+        let __ret: [G; OUT_233] = [__v_18, __v_19];
+        record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_320: usize = 1;
-const IN_320: usize = 1;
-const OUT_320: usize = 1;
-fn aiur_fn_320(
-  inp: [G; IN_320],
+const INPUT_SIZE_234: usize = 1;
+const IN_234: usize = 1;
+const OUT_234: usize = 1;
+fn aiur_fn_234(
+  inp: [G; IN_234],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_320], ExecError> {
+) -> Result<[G; OUT_234], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } };
-    let __v_1: G = __r_arr[0];
-    let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; 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: 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 __v_12: G = G::from_u64(1);
-        let __ret: [G; OUT_320] = [__v_12];
-        record.function_queries[320].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
+    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() {
+      4u64 => {
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; 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: 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() {
+          4u64 => {
+            let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[106].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_106] = unsafe { *(result.output.as_ptr() as *const [G; OUT_106]) }; __ret } else { aiur_fn_106(__args, record, io_buffer, __cu)? } };
+            let __v_9: G = __r_arr[0];
+            let __v_10: G = __r_arr[1];
+            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; 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: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].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];
+            match __v_11.as_canonical_u64() {
+              2u64 => {
+                let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[139].get_mut(&__args[..]) { 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_15: G = __r_arr[0];
+                let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_12, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_16: G = __r_arr[0];
+                match __v_16.as_canonical_u64() {
+                  0u64 => {
+                    let __v_17: G = G::from_u64(0);
+                    let __ret: [G; OUT_234] = [__v_17];
+                    record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
+                  },
+                  _ => {
+                    let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } else { aiur_fn_711(__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_17 - __v_18);
+                    match __v_19.as_canonical_u64() {
+                      0u64 => {
+                        let __v_20: G = G::from_u64(0);
+                        let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_10, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } };
+                        let __v_21: 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_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: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+                        let __v_22: G = __loaded[0];
+                        let __v_23: G = __loaded[1];
+                        let __v_24: G = __loaded[2];
+                        let __v_25: G = __loaded[3];
+                        match __v_22.as_canonical_u64() {
+                          0u64 => {
+                            let __v_26: G = G::from_bool((__v_23 == G::ZERO));
+                            let __ret: [G; OUT_234] = [__v_26];
+                            record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            return Ok(__ret);
+                          },
+                          _ => {
+                            let __v_26: G = G::from_u64(0);
+                            let __ret: [G; OUT_234] = [__v_26];
+                            record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            return Ok(__ret);
+                          },
+                        }
+                      },
+                      _ => {
+                        let __v_20: G = G::from_u64(0);
+                        let __ret: [G; OUT_234] = [__v_20];
+                        record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        return Ok(__ret);
+                      },
+                    }
+                  },
+                }
+              },
+              _ => {
+                let __v_15: G = G::from_u64(0);
+                let __ret: [G; OUT_234] = [__v_15];
+                record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+            }
+          },
+          _ => {
+            let __v_9: G = G::from_u64(0);
+            let __ret: [G; OUT_234] = [__v_9];
+            record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+        }
       },
       _ => {
-        let __v_12: G = G::from_u64(0);
-        let __ret: [G; OUT_320] = [__v_12];
-        record.function_queries[320].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __v_5: G = G::from_u64(0);
+        let __ret: [G; OUT_234] = [__v_5];
+        record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_321: usize = 2;
-const IN_321: usize = 2;
-const OUT_321: usize = 2;
-fn aiur_fn_321(
-  inp: [G; IN_321],
+const INPUT_SIZE_235: usize = 5;
+const IN_235: usize = 5;
+const OUT_235: usize = 2;
+fn aiur_fn_235(
+  inp: [G; IN_235],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_321], ExecError> {
+) -> Result<[G; OUT_235], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __bu_qr: (G, G) = unconstrained_big_uint_div_mod_helper(__v_0, __v_1, record)?;
-    let __v_2: G = __bu_qr.0;
-    let __v_3: G = __bu_qr.1;
-    let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[316].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_316] = unsafe { *(result.output.as_ptr() as *const [G; OUT_316]) }; __ret } else { aiur_fn_316(__args, record, io_buffer, __cu)? } };
-    let __v_4: G = __r_arr[0];
-    let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_4, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } else { aiur_fn_306(__args, record, io_buffer, __cu)? } };
-    let __v_5: G = __r_arr[0];
-    let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } };
-    let __v_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } };
-    let __v_7: G = __r_arr[0];
-    if (__v_6 != __v_7) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_7.as_canonical_u64() });
-    }
-    let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } else { aiur_fn_320(__args, record, io_buffer, __cu)? } };
-    let __v_8: G = __r_arr[0];
-    match __v_8.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 = G::from_u64(2);
+    let __v_6: G = { let __a_val = __v_3.as_canonical_u64(); let __b_val = __v_5.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_6.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_321] = [__v_2, __v_3];
-        record.function_queries[321].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[304].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_304] = unsafe { *(result.output.as_ptr() as *const [G; OUT_304]) }; __ret } else { aiur_fn_304(__args, record, io_buffer, __cu)? } };
-        let __v_9: G = __r_arr[0];
-        let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_9, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[311].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_311] = unsafe { *(result.output.as_ptr() as *const [G; OUT_311]) }; __ret } else { aiur_fn_311(__args, record, io_buffer, __cu)? } };
-        let __v_10: G = __r_arr[0];
-        let __v_11: G = G::from_u64(1);
-        if (__v_10 != __v_11) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_10.as_canonical_u64(), rhs: __v_11.as_canonical_u64() });
-        }
-        let __ret: [G; OUT_321] = [__v_2, __v_3];
-        record.function_queries[321].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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 = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __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_235] = [__v_7, __v_11];
+        record.function_queries[235].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64()));
+        let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } };
+        let __v_7: G = __r_arr[0];
+        let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[225].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_225] = unsafe { *(result.output.as_ptr() as *const [G; OUT_225]) }; __ret } else { aiur_fn_225(__args, record, io_buffer, __cu)? } };
+        let __v_8: G = __r_arr[0];
+        let __v_9: G = __r_arr[1];
+        match __v_8.as_canonical_u64() {
+          0u64 => {
+            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 = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; 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_235] = [__v_10, __v_14];
+            record.function_queries[235].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          1u64 => {
+            let __v_10: G = (__v_1 + __v_2);
+            let __v_11: G = G::from_u64(1);
+            let __v_12: G = (__v_10 + __v_11);
+            let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_0, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } };
+            let __v_13: G = __r_arr[0];
+            let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[234].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_234] = unsafe { *(result.output.as_ptr() as *const [G; OUT_234]) }; __ret } else { aiur_fn_234(__args, record, io_buffer, __cu)? } };
+            let __v_14: G = __r_arr[0];
+            match __v_14.as_canonical_u64() {
+              0u64 => {
+                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 = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; 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_235] = [__v_15, __v_19];
+                record.function_queries[235].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_0, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } };
+                let __v_15: G = __r_arr[0];
+                let __v_16: G = G::from_u64(1);
+                let __v_17: G = (__v_4 + __v_16);
+                let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_0, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } };
+                let __v_18: G = __r_arr[0];
+                let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[225].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_225] = unsafe { *(result.output.as_ptr() as *const [G; OUT_225]) }; __ret } else { aiur_fn_225(__args, record, io_buffer, __cu)? } };
+                let __v_19: G = __r_arr[0];
+                let __v_20: G = __r_arr[1];
+                match __v_19.as_canonical_u64() {
+                  1u64 => {
+                    let __v_21: G = G::from_u64(1);
+                    let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_20, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[109].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_109] = unsafe { *(result.output.as_ptr() as *const [G; OUT_109]) }; __ret } else { aiur_fn_109(__args, record, io_buffer, __cu)? } };
+                    let __v_22: G = __r_arr[0];
+                    let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } else { aiur_fn_227(__args, record, io_buffer, __cu)? } };
+                    let __v_23: G = __r_arr[0];
+                    let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_23, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } };
+                    let __v_24: G = __r_arr[0];
+                    let __ret: [G; OUT_235] = [__v_21, __v_24];
+                    record.function_queries[235].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
+                  },
+                  _ => {
+                    let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_15, __v_9, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } };
+                    let __v_21: G = __r_arr[0];
+                    let __v_22: G = __r_arr[1];
+                    let __ret: [G; OUT_235] = [__v_21, __v_22];
+                    record.function_queries[235].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
+                  },
+                }
+              },
+            }
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64()));
+          },
+        }
       },
     }
   })
 }
 
-const INPUT_SIZE_322: usize = 2;
-const IN_322: usize = 2;
-const OUT_322: usize = 1;
-fn aiur_fn_322(
-  inp: [G; IN_322],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_322], 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_321] = { let __args: [G; IN_321] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } else { aiur_fn_321(__args, record, io_buffer, __cu)? } };
-    let __v_2: G = __r_arr[0];
-    let __v_3: G = __r_arr[1];
-    let __ret: [G; OUT_322] = [__v_2];
-    record.function_queries[322].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_323: usize = 2;
-const IN_323: usize = 2;
-const OUT_323: usize = 1;
-fn aiur_fn_323(
-  inp: [G; IN_323],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_323], 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_321] = { let __args: [G; IN_321] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } else { aiur_fn_321(__args, record, io_buffer, __cu)? } };
-    let __v_2: G = __r_arr[0];
-    let __v_3: G = __r_arr[1];
-    let __ret: [G; OUT_323] = [__v_3];
-    record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_324: usize = 2;
-const IN_324: usize = 2;
-const OUT_324: usize = 1;
-fn aiur_fn_324(
-  inp: [G; IN_324],
+const INPUT_SIZE_236: usize = 3;
+const IN_236: usize = 3;
+const OUT_236: usize = 2;
+fn aiur_fn_236(
+  inp: [G; IN_236],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_324], ExecError> {
+) -> Result<[G; OUT_236], 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_320] = { let __args: [G; IN_320] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } else { aiur_fn_320(__args, record, io_buffer, __cu)? } };
-    let __v_2: G = __r_arr[0];
-    match __v_2.as_canonical_u64() {
+    let __v_2: G = inp[2];
+    let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } else { aiur_fn_711(__args, record, io_buffer, __cu)? } };
+    let __v_3: G = __r_arr[0];
+    let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[140].get_mut(&__args[..]) { 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_4: G = __r_arr[0];
+    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_5: G = __r_arr[0];
+    let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[139].get_mut(&__args[..]) { 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_6: G = __r_arr[0];
+    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_7: G = __r_arr[0];
+    match __v_7.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_324] = [__v_0];
-        record.function_queries[324].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } else { aiur_fn_323(__args, record, io_buffer, __cu)? } };
-        let __v_3: G = __r_arr[0];
-        let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } else { aiur_fn_324(__args, record, io_buffer, __cu)? } };
-        let __v_4: G = __r_arr[0];
-        let __ret: [G; OUT_324] = [__v_4];
-        record.function_queries[324].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
+        let __v_8: G = G::from_u64(1);
+        let __v_9: G = { let __a_val = __v_3.as_canonical_u64(); let __b_val = __v_8.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_9.as_canonical_u64() {
+          1u64 => {
+            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 = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; 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_236] = [__v_10, __v_14];
+            record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            let __v_10: G = G::from_u64(0);
+            let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } };
+            let __v_11: G = __r_arr[0];
+            let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[225].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_225] = unsafe { *(result.output.as_ptr() as *const [G; OUT_225]) }; __ret } else { aiur_fn_225(__args, record, io_buffer, __cu)? } };
+            let __v_12: G = __r_arr[0];
+            let __v_13: G = __r_arr[1];
+            match __v_12.as_canonical_u64() {
+              1u64 => {
+                let __v_14: G = G::from_u64(1);
+                let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_1, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } };
+                let __v_15: G = __r_arr[0];
+                let __v_16: G = G::from_u64(1);
+                let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } else { aiur_fn_227(__args, record, io_buffer, __cu)? } };
+                let __v_18: G = __r_arr[0];
+                let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_18, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } };
+                let __v_19: G = __r_arr[0];
+                let __ret: [G; OUT_236] = [__v_16, __v_19];
+                record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                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 = G::from_u64(0);
+                let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; 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_236] = [__v_14, __v_18];
+                record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+            }
+          },
+        }
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+        match __v_5.as_canonical_u64() {
+          1u64 => {
+            let __v_8: G = G::from_u64(1);
+            let __v_9: G = { let __a_val = __v_3.as_canonical_u64(); let __b_val = __v_8.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_9.as_canonical_u64() {
+              1u64 => {
+                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 = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; 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_236] = [__v_10, __v_14];
+                record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                let __v_10: G = G::from_u64(0);
+                let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } };
+                let __v_11: G = __r_arr[0];
+                let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[225].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_225] = unsafe { *(result.output.as_ptr() as *const [G; OUT_225]) }; __ret } else { aiur_fn_225(__args, record, io_buffer, __cu)? } };
+                let __v_12: G = __r_arr[0];
+                let __v_13: G = __r_arr[1];
+                match __v_12.as_canonical_u64() {
+                  1u64 => {
+                    let __v_14: G = G::from_u64(1);
+                    let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_1, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } };
+                    let __v_15: G = __r_arr[0];
+                    let __v_16: G = G::from_u64(1);
+                    let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { 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_17: G = __r_arr[0];
+                    let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { 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_18: G = __r_arr[0];
+                    let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } else { aiur_fn_227(__args, record, io_buffer, __cu)? } };
+                    let __v_19: G = __r_arr[0];
+                    let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_19, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } };
+                    let __v_20: G = __r_arr[0];
+                    let __ret: [G; OUT_236] = [__v_16, __v_20];
+                    record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
+                  },
+                  _ => {
+                    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 = G::from_u64(0);
+                    let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; 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_236] = [__v_14, __v_18];
+                    record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
+                  },
+                }
+              },
+            }
+          },
+          _ => {
+            let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[237].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_237] = unsafe { *(result.output.as_ptr() as *const [G; OUT_237]) }; __ret } else { aiur_fn_237(__args, record, io_buffer, __cu)? } };
+            let __v_8: G = __r_arr[0];
+            let __v_9: G = __r_arr[1];
+            let __ret: [G; OUT_236] = [__v_8, __v_9];
+            record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+        }
       },
     }
   })
 }
 
-const INPUT_SIZE_325: usize = 2;
-const IN_325: usize = 2;
-const OUT_325: usize = 1;
-fn aiur_fn_325(
-  inp: [G; IN_325],
+const INPUT_SIZE_237: usize = 3;
+const IN_237: usize = 3;
+const OUT_237: usize = 2;
+fn aiur_fn_237(
+  inp: [G; IN_237],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_325], ExecError> {
+) -> Result<[G; OUT_237], 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_320] = { let __args: [G; IN_320] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } else { aiur_fn_320(__args, record, io_buffer, __cu)? } };
-    let __v_2: G = __r_arr[0];
-    match __v_2.as_canonical_u64() {
+    let __v_2: G = inp[2];
+    let __v_3: G = G::from_u64(2);
+    let __v_4: G = { let __a_val = __v_2.as_canonical_u64(); let __b_val = __v_3.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_4.as_canonical_u64() {
       1u64 => {
-        let __v_3: G = G::from_u64(0);
-        let __v_4: G = G::from_u64(1);
         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 __v_12: G = G::from_u64(1);
-        let __v_13: G = G::from_u64(1);
-        let __v_14: G = { let __values: [G; 10] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __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 __v_15: G = { let __values: [G; 10] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14]; 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_325] = [__v_15];
-        record.function_queries[325].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __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_237] = [__v_5, __v_9];
+        record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __v_3: G = G::from_u64(0);
-        let __v_4: G = G::from_u64(2);
+      _ => {
         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 __v_12: G = G::from_u64(1);
-        let __v_13: G = G::from_u64(1);
-        let __v_14: G = { let __values: [G; 10] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __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 __v_15: G = { let __values: [G; 10] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14]; 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_321] = { let __args: [G; IN_321] = [__v_1, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } else { aiur_fn_321(__args, record, io_buffer, __cu)? } };
-        let __v_16: G = __r_arr[0];
-        let __v_17: G = __r_arr[1];
-        let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_0, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[316].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_316] = unsafe { *(result.output.as_ptr() as *const [G; OUT_316]) }; __ret } else { aiur_fn_316(__args, record, io_buffer, __cu)? } };
-        let __v_18: G = __r_arr[0];
-        let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } };
-        let __v_19: G = __r_arr[0];
-        let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } };
-        let __v_20: G = __r_arr[0];
-        let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[325].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_325] = unsafe { *(result.output.as_ptr() as *const [G; OUT_325]) }; __ret } else { aiur_fn_325(__args, record, io_buffer, __cu)? } };
-        let __v_21: G = __r_arr[0];
-        let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } else { aiur_fn_320(__args, record, io_buffer, __cu)? } };
-        let __v_22: G = __r_arr[0];
-        match __v_22.as_canonical_u64() {
+        let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__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_713] = { let __args: [G; IN_713] = [__v_1, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } };
+        let __v_8: G = __r_arr[0];
+        let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[225].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_225] = unsafe { *(result.output.as_ptr() as *const [G; OUT_225]) }; __ret } else { aiur_fn_225(__args, record, io_buffer, __cu)? } };
+        let __v_9: G = __r_arr[0];
+        let __v_10: G = __r_arr[1];
+        match __v_9.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_325] = [__v_21];
-            record.function_queries[325].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          0u64 => {
-            let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_0, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[316].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_316] = unsafe { *(result.output.as_ptr() as *const [G; OUT_316]) }; __ret } else { aiur_fn_316(__args, record, io_buffer, __cu)? } };
-            let __v_23: G = __r_arr[0];
-            let __ret: [G; OUT_325] = [__v_23];
-            record.function_queries[325].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
+            let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[225].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_225] = unsafe { *(result.output.as_ptr() as *const [G; OUT_225]) }; __ret } else { aiur_fn_225(__args, record, io_buffer, __cu)? } };
+            let __v_11: G = __r_arr[0];
+            let __v_12: G = __r_arr[1];
+            match __v_11.as_canonical_u64() {
+              1u64 => {
+                let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_0, __v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } };
+                let __v_13: G = __r_arr[0];
+                let __v_14: G = __r_arr[1];
+                match __v_13.as_canonical_u64() {
+                  1u64 => {
+                    let __v_15: G = G::from_u64(2);
+                    let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_1, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } };
+                    let __v_16: G = __r_arr[0];
+                    let __v_17: G = G::from_u64(1);
+                    let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_14, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } };
+                    let __v_18: G = __r_arr[0];
+                    let __ret: [G; OUT_237] = [__v_17, __v_18];
+                    record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
+                  },
+                  _ => {
+                    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 = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; 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_237] = [__v_15, __v_19];
+                    record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
+                  },
+                }
+              },
+              _ => {
+                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; 4] = [__v_14, __v_15, __v_16, __v_16]; 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_237] = [__v_13, __v_17];
+                record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+            }
           },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_22.as_canonical_u64()));
+            let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[225].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_225] = unsafe { *(result.output.as_ptr() as *const [G; OUT_225]) }; __ret } else { aiur_fn_225(__args, record, io_buffer, __cu)? } };
+            let __v_11: G = __r_arr[0];
+            let __v_12: G = __r_arr[1];
+            match __v_11.as_canonical_u64() {
+              1u64 => {
+                let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_0, __v_6, __v_12, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[238].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_238] = unsafe { *(result.output.as_ptr() as *const [G; OUT_238]) }; __ret } else { aiur_fn_238(__args, record, io_buffer, __cu)? } };
+                let __v_13: G = __r_arr[0];
+                let __v_14: G = __r_arr[1];
+                let __ret: [G; OUT_237] = [__v_13, __v_14];
+                record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                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; 4] = [__v_14, __v_15, __v_16, __v_16]; 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_237] = [__v_13, __v_17];
+                record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+            }
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
     }
   })
 }
 
-const INPUT_SIZE_326: usize = 16;
-const IN_326: usize = 16;
-const OUT_326: usize = 8;
-fn aiur_fn_326(
-  inp: [G; IN_326],
+const INPUT_SIZE_238: usize = 4;
+const IN_238: usize = 4;
+const OUT_238: usize = 2;
+fn aiur_fn_238(
+  inp: [G; IN_238],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_326], ExecError> {
+) -> Result<[G; OUT_238], 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 = if unconstrained { Bytes2::and(&__v_0, &__v_8) } else { bytes2_and_value(__v_0, __v_8, record) };
-    let __v_17: G = if unconstrained { Bytes2::and(&__v_1, &__v_9) } else { bytes2_and_value(__v_1, __v_9, record) };
-    let __v_18: G = if unconstrained { Bytes2::and(&__v_2, &__v_10) } else { bytes2_and_value(__v_2, __v_10, record) };
-    let __v_19: G = if unconstrained { Bytes2::and(&__v_3, &__v_11) } else { bytes2_and_value(__v_3, __v_11, record) };
-    let __v_20: G = if unconstrained { Bytes2::and(&__v_4, &__v_12) } else { bytes2_and_value(__v_4, __v_12, record) };
-    let __v_21: G = if unconstrained { Bytes2::and(&__v_5, &__v_13) } else { bytes2_and_value(__v_5, __v_13, record) };
-    let __v_22: G = if unconstrained { Bytes2::and(&__v_6, &__v_14) } else { bytes2_and_value(__v_6, __v_14, record) };
-    let __v_23: G = if unconstrained { Bytes2::and(&__v_7, &__v_15) } else { bytes2_and_value(__v_7, __v_15, record) };
-    let __ret: [G; OUT_326] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23];
-    record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
+    let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[141].get_mut(&__args[..]) { 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_4: G = __r_arr[0];
+    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_5: G = __r_arr[0];
+    let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } else { aiur_fn_147(__args, record, io_buffer, __cu)? } };
+    let __v_6: G = __r_arr[0];
+    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_7: G = __r_arr[0];
+    let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { 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_8: G = __r_arr[0];
+    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_9: G = __r_arr[0];
+    let __v_10: G = (__v_7 + __v_9);
+    let __v_11: G = G::from_u64(1);
+    let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { 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_12: G = __r_arr[0];
+    let __v_13: G = (__v_11 - __v_12);
+    let __v_14: G = G::from_u64(1);
+    let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { 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_15: G = __r_arr[0];
+    let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { 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_16: G = __r_arr[0];
+    let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { 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_17: G = __r_arr[0];
+    let __v_18: G = (__v_14 - __v_17);
+    let __v_19: G = (__v_13 * __v_18);
+    let __v_20: G = (__v_10 * __v_19);
+    let __v_21: G = (__v_5 + __v_20);
+    match __v_21.as_canonical_u64() {
+      0u64 => {
+        let __v_22: G = G::from_u64(0);
+        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 __v_26: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_25]; 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_238] = [__v_22, __v_26];
+        record.function_queries[238].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __v_22: G = G::from_u64(2);
+        let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_3, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } };
+        let __v_23: G = __r_arr[0];
+        match __v_5.as_canonical_u64() {
+          1u64 => {
+            let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_1, __v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } };
+            let __v_24: G = __r_arr[0];
+            let __v_25: G = __r_arr[1];
+            match __v_24.as_canonical_u64() {
+              1u64 => {
+                let __v_26: G = G::from_u64(2);
+                let __ret: [G; OUT_238] = [__v_26, __v_25];
+                record.function_queries[238].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                let __v_26: G = G::from_u64(0);
+                let __v_27: G = G::from_u64(0);
+                let __v_28: G = G::from_u64(0);
+                let __v_29: G = G::from_u64(0);
+                let __v_30: G = { let __values: [G; 4] = [__v_27, __v_28, __v_29, __v_29]; 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_238] = [__v_26, __v_30];
+                record.function_queries[238].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+            }
+          },
+          _ => {
+            let __v_24: G = G::from_u64(2);
+            let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_0, __v_1, __v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } else { aiur_fn_239(__args, record, io_buffer, __cu)? } };
+            let __v_25: G = __r_arr[0];
+            let __ret: [G; OUT_238] = [__v_24, __v_25];
+            record.function_queries[238].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+        }
+      },
+    }
   })
 }
 
-const INPUT_SIZE_327: usize = 16;
-const IN_327: usize = 16;
-const OUT_327: usize = 8;
-fn aiur_fn_327(
-  inp: [G; IN_327],
+const INPUT_SIZE_239: usize = 4;
+const IN_239: usize = 4;
+const OUT_239: usize = 1;
+fn aiur_fn_239(
+  inp: [G; IN_239],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_327], ExecError> {
+) -> Result<[G; OUT_239], 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 = if unconstrained { Bytes2::or(&__v_0, &__v_8) } else { bytes2_or_value(__v_0, __v_8, record) };
-    let __v_17: G = if unconstrained { Bytes2::or(&__v_1, &__v_9) } else { bytes2_or_value(__v_1, __v_9, record) };
-    let __v_18: G = if unconstrained { Bytes2::or(&__v_2, &__v_10) } else { bytes2_or_value(__v_2, __v_10, record) };
-    let __v_19: G = if unconstrained { Bytes2::or(&__v_3, &__v_11) } else { bytes2_or_value(__v_3, __v_11, record) };
-    let __v_20: G = if unconstrained { Bytes2::or(&__v_4, &__v_12) } else { bytes2_or_value(__v_4, __v_12, record) };
-    let __v_21: G = if unconstrained { Bytes2::or(&__v_5, &__v_13) } else { bytes2_or_value(__v_5, __v_13, record) };
-    let __v_22: G = if unconstrained { Bytes2::or(&__v_6, &__v_14) } else { bytes2_or_value(__v_6, __v_14, record) };
-    let __v_23: G = if unconstrained { Bytes2::or(&__v_7, &__v_15) } else { bytes2_or_value(__v_7, __v_15, record) };
-    let __ret: [G; OUT_327] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23];
-    record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __v_4: G = G::from_u64(2);
+    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 __v_8: G = G::from_u64(0);
+    let __v_9: G = { let __values: [G; 4] = [__v_4, __v_0, __v_7, __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 __v_10: G = G::from_u64(3);
+    let __v_11: G = G::from_u64(3);
+    let __v_12: G = G::from_u64(0);
+    let __v_13: G = { let __values: [G; 4] = [__v_11, __v_9, __v_1, __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 __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } else { aiur_fn_227(__args, record, io_buffer, __cu)? } };
+    let __v_14: G = __r_arr[0];
+    let __v_15: G = G::from_u64(0);
+    let __v_16: G = { let __values: [G; 4] = [__v_10, __v_13, __v_14, __v_15]; 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_228] = { let __args: [G; IN_228] = [__v_16, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } };
+    let __v_17: G = __r_arr[0];
+    let __ret: [G; OUT_239] = [__v_17];
+    record.function_queries[239].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_328: usize = 16;
-const IN_328: usize = 16;
-const OUT_328: usize = 8;
-fn aiur_fn_328(
-  inp: [G; IN_328],
+const INPUT_SIZE_240: usize = 10;
+const IN_240: usize = 10;
+const OUT_240: usize = 8;
+fn aiur_fn_240(
+  inp: [G; IN_240],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_328], ExecError> {
+) -> Result<[G; OUT_240], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -29733,857 +22502,874 @@ fn aiur_fn_328(
     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 = if unconstrained { Bytes2::xor(&__v_0, &__v_8) } else { bytes2_xor_value(__v_0, __v_8, record) };
-    let __v_17: G = if unconstrained { Bytes2::xor(&__v_1, &__v_9) } else { bytes2_xor_value(__v_1, __v_9, record) };
-    let __v_18: G = if unconstrained { Bytes2::xor(&__v_2, &__v_10) } else { bytes2_xor_value(__v_2, __v_10, record) };
-    let __v_19: G = if unconstrained { Bytes2::xor(&__v_3, &__v_11) } else { bytes2_xor_value(__v_3, __v_11, record) };
-    let __v_20: G = if unconstrained { Bytes2::xor(&__v_4, &__v_12) } else { bytes2_xor_value(__v_4, __v_12, record) };
-    let __v_21: G = if unconstrained { Bytes2::xor(&__v_5, &__v_13) } else { bytes2_xor_value(__v_5, __v_13, record) };
-    let __v_22: G = if unconstrained { Bytes2::xor(&__v_6, &__v_14) } else { bytes2_xor_value(__v_6, __v_14, record) };
-    let __v_23: G = if unconstrained { Bytes2::xor(&__v_7, &__v_15) } else { bytes2_xor_value(__v_7, __v_15, record) };
-    let __ret: [G; OUT_328] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23];
-    record.function_queries[328].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_329: usize = 2;
-const IN_329: usize = 2;
-const OUT_329: usize = 1;
-fn aiur_fn_329(
-  inp: [G; IN_329],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_329], 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 __v_12: G = G::from_u64(1);
-        let __v_13: G = G::from_u64(1);
-        let __v_14: G = { let __values: [G; 10] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __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_329] = [__v_14];
-        record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    match __v_9.as_canonical_u64() {
+      8u64 => {
+        let __ret: [G; OUT_240] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8];
+        record.function_queries[240].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_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: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
-        let __v_12: G = __loaded[0];
-        let __v_13: G = __loaded[1];
-        let __v_14: G = __loaded[2];
-        let __v_15: G = __loaded[3];
-        let __v_16: G = __loaded[4];
-        let __v_17: G = __loaded[5];
-        let __v_18: G = __loaded[6];
-        let __v_19: G = __loaded[7];
-        let __v_20: G = __loaded[8];
-        let __v_21: G = __loaded[9];
-        match __v_12.as_canonical_u64() {
-          1u64 => {
-            let __v_22: G = G::from_u64(1);
-            let __v_23: G = G::from_u64(1);
-            let __v_24: G = { let __values: [G; 10] = [__v_22, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; 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_329] = [__v_24];
-            record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          0u64 => {
-            let __v_22: G = G::from_u64(0);
-            let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[326].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_326] = unsafe { *(result.output.as_ptr() as *const [G; OUT_326]) }; __ret } else { aiur_fn_326(__args, record, io_buffer, __cu)? } };
-            let __v_23: G = __r_arr[0];
-            let __v_24: G = __r_arr[1];
-            let __v_25: G = __r_arr[2];
-            let __v_26: G = __r_arr[3];
-            let __v_27: G = __r_arr[4];
-            let __v_28: G = __r_arr[5];
-            let __v_29: G = __r_arr[6];
-            let __v_30: G = __r_arr[7];
-            let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } else { aiur_fn_329(__args, record, io_buffer, __cu)? } };
-            let __v_31: G = __r_arr[0];
-            let __v_32: G = { let __values: [G; 10] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; 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_329] = [__v_32];
-            record.function_queries[329].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_330: usize = 2;
-const IN_330: usize = 2;
-const OUT_330: usize = 1;
-fn aiur_fn_330(
-  inp: [G; IN_330],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_330], 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_330] = [__v_1];
-        record.function_queries[330].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_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: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
-        let __v_12: G = __loaded[0];
-        let __v_13: G = __loaded[1];
-        let __v_14: G = __loaded[2];
-        let __v_15: G = __loaded[3];
-        let __v_16: G = __loaded[4];
-        let __v_17: G = __loaded[5];
-        let __v_18: G = __loaded[6];
-        let __v_19: G = __loaded[7];
-        let __v_20: G = __loaded[8];
-        let __v_21: G = __loaded[9];
-        match __v_12.as_canonical_u64() {
+        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_10: G = __loaded[0];
+        let __v_11: G = __loaded[1];
+        let __v_12: G = __loaded[2];
+        match __v_10.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_330] = [__v_0];
-            record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_240] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8];
+            record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __v_22: G = G::from_u64(0);
-            let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[327].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_327] = unsafe { *(result.output.as_ptr() as *const [G; OUT_327]) }; __ret } else { aiur_fn_327(__args, record, io_buffer, __cu)? } };
-            let __v_23: G = __r_arr[0];
-            let __v_24: G = __r_arr[1];
-            let __v_25: G = __r_arr[2];
-            let __v_26: G = __r_arr[3];
-            let __v_27: G = __r_arr[4];
-            let __v_28: G = __r_arr[5];
-            let __v_29: G = __r_arr[6];
-            let __v_30: G = __r_arr[7];
-            let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[330].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_330] = unsafe { *(result.output.as_ptr() as *const [G; OUT_330]) }; __ret } else { aiur_fn_330(__args, record, io_buffer, __cu)? } };
-            let __v_31: G = __r_arr[0];
-            let __v_32: G = { let __values: [G; 10] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; 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_330] = [__v_32];
-            record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
+            match __v_9.as_canonical_u64() {
+              0u64 => {
+                let __v_13: G = G::from_u64(1);
+                let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_12, __v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[240].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_240] = unsafe { *(result.output.as_ptr() as *const [G; OUT_240]) }; __ret } else { aiur_fn_240(__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 __v_17: G = __r_arr[3];
+                let __v_18: G = __r_arr[4];
+                let __v_19: G = __r_arr[5];
+                let __v_20: G = __r_arr[6];
+                let __v_21: G = __r_arr[7];
+                let __ret: [G; OUT_240] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
+                record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              1u64 => {
+                let __v_13: G = G::from_u64(2);
+                let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_12, __v_1, __v_11, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[240].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_240] = unsafe { *(result.output.as_ptr() as *const [G; OUT_240]) }; __ret } else { aiur_fn_240(__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 __v_17: G = __r_arr[3];
+                let __v_18: G = __r_arr[4];
+                let __v_19: G = __r_arr[5];
+                let __v_20: G = __r_arr[6];
+                let __v_21: G = __r_arr[7];
+                let __ret: [G; OUT_240] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
+                record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              2u64 => {
+                let __v_13: G = G::from_u64(3);
+                let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_12, __v_1, __v_2, __v_11, __v_4, __v_5, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[240].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_240] = unsafe { *(result.output.as_ptr() as *const [G; OUT_240]) }; __ret } else { aiur_fn_240(__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 __v_17: G = __r_arr[3];
+                let __v_18: G = __r_arr[4];
+                let __v_19: G = __r_arr[5];
+                let __v_20: G = __r_arr[6];
+                let __v_21: G = __r_arr[7];
+                let __ret: [G; OUT_240] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
+                record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              3u64 => {
+                let __v_13: G = G::from_u64(4);
+                let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_12, __v_1, __v_2, __v_3, __v_11, __v_5, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[240].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_240] = unsafe { *(result.output.as_ptr() as *const [G; OUT_240]) }; __ret } else { aiur_fn_240(__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 __v_17: G = __r_arr[3];
+                let __v_18: G = __r_arr[4];
+                let __v_19: G = __r_arr[5];
+                let __v_20: G = __r_arr[6];
+                let __v_21: G = __r_arr[7];
+                let __ret: [G; OUT_240] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
+                record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              4u64 => {
+                let __v_13: G = G::from_u64(5);
+                let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_11, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[240].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_240] = unsafe { *(result.output.as_ptr() as *const [G; OUT_240]) }; __ret } else { aiur_fn_240(__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 __v_17: G = __r_arr[3];
+                let __v_18: G = __r_arr[4];
+                let __v_19: G = __r_arr[5];
+                let __v_20: G = __r_arr[6];
+                let __v_21: G = __r_arr[7];
+                let __ret: [G; OUT_240] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
+                record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              5u64 => {
+                let __v_13: G = G::from_u64(6);
+                let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_11, __v_7, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[240].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_240] = unsafe { *(result.output.as_ptr() as *const [G; OUT_240]) }; __ret } else { aiur_fn_240(__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 __v_17: G = __r_arr[3];
+                let __v_18: G = __r_arr[4];
+                let __v_19: G = __r_arr[5];
+                let __v_20: G = __r_arr[6];
+                let __v_21: G = __r_arr[7];
+                let __ret: [G; OUT_240] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
+                record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              6u64 => {
+                let __v_13: G = G::from_u64(7);
+                let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_11, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[240].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_240] = unsafe { *(result.output.as_ptr() as *const [G; OUT_240]) }; __ret } else { aiur_fn_240(__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 __v_17: G = __r_arr[3];
+                let __v_18: G = __r_arr[4];
+                let __v_19: G = __r_arr[5];
+                let __v_20: G = __r_arr[6];
+                let __v_21: G = __r_arr[7];
+                let __ret: [G; OUT_240] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
+                record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                let __v_13: G = G::from_u64(8);
+                let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_11, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[240].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_240] = unsafe { *(result.output.as_ptr() as *const [G; OUT_240]) }; __ret } else { aiur_fn_240(__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 __v_17: G = __r_arr[3];
+                let __v_18: G = __r_arr[4];
+                let __v_19: G = __r_arr[5];
+                let __v_20: G = __r_arr[6];
+                let __v_21: G = __r_arr[7];
+                let __ret: [G; OUT_240] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
+                record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+            }
           },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64()));
+            return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64()));
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
     }
   })
 }
 
-const INPUT_SIZE_331: usize = 2;
-const IN_331: usize = 2;
-const OUT_331: usize = 1;
-fn aiur_fn_331(
-  inp: [G; IN_331],
+const INPUT_SIZE_241: usize = 2;
+const IN_241: usize = 2;
+const OUT_241: usize = 1;
+fn aiur_fn_241(
+  inp: [G; IN_241],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_331], ExecError> {
+) -> Result<[G; OUT_241], 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_331] = [__v_1];
-        record.function_queries[331].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    match __v_1.as_canonical_u64() {
+      0u64 => {
+        let __ret: [G; OUT_241] = [__v_0];
+        record.function_queries[241].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_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: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
-        let __v_12: G = __loaded[0];
-        let __v_13: G = __loaded[1];
-        let __v_14: G = __loaded[2];
-        let __v_15: G = __loaded[3];
-        let __v_16: G = __loaded[4];
-        let __v_17: G = __loaded[5];
-        let __v_18: G = __loaded[6];
-        let __v_19: G = __loaded[7];
-        let __v_20: G = __loaded[8];
-        let __v_21: G = __loaded[9];
-        match __v_12.as_canonical_u64() {
+      _ => {
+        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_331] = [__v_0];
-            record.function_queries[331].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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_241] = [__v_7];
+            record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __v_22: G = G::from_u64(0);
-            let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } else { aiur_fn_328(__args, record, io_buffer, __cu)? } };
-            let __v_23: G = __r_arr[0];
-            let __v_24: G = __r_arr[1];
-            let __v_25: G = __r_arr[2];
-            let __v_26: G = __r_arr[3];
-            let __v_27: G = __r_arr[4];
-            let __v_28: G = __r_arr[5];
-            let __v_29: G = __r_arr[6];
-            let __v_30: G = __r_arr[7];
-            let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[331].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_331] = unsafe { *(result.output.as_ptr() as *const [G; OUT_331]) }; __ret } else { aiur_fn_331(__args, record, io_buffer, __cu)? } };
-            let __v_31: G = __r_arr[0];
-            let __v_32: G = { let __values: [G; 10] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; 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_331] = [__v_32];
-            record.function_queries[331].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __v_5: G = G::from_u64(1);
+            let __v_6: G = (__v_1 - __v_5);
+            let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } else { aiur_fn_241(__args, record, io_buffer, __cu)? } };
+            let __v_7: G = __r_arr[0];
+            let __ret: [G; OUT_241] = [__v_7];
+            record.function_queries[241].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()));
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
     }
   })
 }
 
-const INPUT_SIZE_332: usize = 2;
-const IN_332: usize = 2;
-const OUT_332: usize = 1;
-fn aiur_fn_332(
-  inp: [G; IN_332],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_332], 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(0);
-    let __v_3: G = G::from_u64(2);
-    let __v_4: G = G::from_u64(0);
-    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(1);
-    let __v_12: G = G::from_u64(1);
-    let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; 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_14: G = { let __values: [G; 10] = [__v_2, __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 __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[325].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_325] = unsafe { *(result.output.as_ptr() as *const [G; OUT_325]) }; __ret } else { aiur_fn_325(__args, record, io_buffer, __cu)? } };
-    let __v_15: G = __r_arr[0];
-    let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_0, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[316].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_316] = unsafe { *(result.output.as_ptr() as *const [G; OUT_316]) }; __ret } else { aiur_fn_316(__args, record, io_buffer, __cu)? } };
-    let __v_16: G = __r_arr[0];
-    let __ret: [G; OUT_332] = [__v_16];
-    record.function_queries[332].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_333: usize = 2;
-const IN_333: usize = 2;
-const OUT_333: usize = 1;
-fn aiur_fn_333(
-  inp: [G; IN_333],
+const INPUT_SIZE_242: usize = 1;
+const IN_242: usize = 1;
+const OUT_242: usize = 1;
+fn aiur_fn_242(
+  inp: [G; IN_242],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_333], ExecError> {
+) -> Result<[G; OUT_242], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
+    let __v_1: G = G::from_u64(0);
     let __v_2: G = G::from_u64(0);
-    let __v_3: G = G::from_u64(2);
+    let __v_3: G = G::from_u64(0);
     let __v_4: G = G::from_u64(0);
     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(1);
-    let __v_12: G = G::from_u64(1);
-    let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; 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_14: G = { let __values: [G; 10] = [__v_2, __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 __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[325].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_325] = unsafe { *(result.output.as_ptr() as *const [G; OUT_325]) }; __ret } else { aiur_fn_325(__args, record, io_buffer, __cu)? } };
-    let __v_15: G = __r_arr[0];
-    let __r_arr: [G; OUT_322] = { let __args: [G; IN_322] = [__v_0, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[322].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_322] = unsafe { *(result.output.as_ptr() as *const [G; OUT_322]) }; __ret } else { aiur_fn_322(__args, record, io_buffer, __cu)? } };
-    let __v_16: G = __r_arr[0];
-    let __ret: [G; OUT_333] = [__v_16];
-    record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
+    let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[240].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_240] = unsafe { *(result.output.as_ptr() as *const [G; OUT_240]) }; __ret } else { aiur_fn_240(__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 = G::from_u64(8);
+    let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_0, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } else { aiur_fn_241(__args, record, io_buffer, __cu)? } };
+    let __v_19: 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_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];
+    let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_20.as_canonical_u64() {
+  1u64 => {
+    let __v_23: G = G::from_u64(1);
+    let __v_24: G = G::from_u64(1);
+    let __v_25: G = { let __values: [G; 10] = [__v_23, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24]; 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 } };
+    break '__mc_0 [__v_25];
+  },
+  _ => {
+    let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } else { aiur_fn_242(__args, record, io_buffer, __cu)? } };
+    let __v_23: G = __r_arr[0];
+    break '__mc_0 [__v_23];
+  },
+}
+ };
+    let __v_23: G = __mc_out___mc_0[0];
+    let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_23.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).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_24: G = __loaded[0];
+    let __v_25: G = __loaded[1];
+    let __v_26: G = __loaded[2];
+    let __v_27: G = __loaded[3];
+    let __v_28: G = __loaded[4];
+    let __v_29: G = __loaded[5];
+    let __v_30: G = __loaded[6];
+    let __v_31: G = __loaded[7];
+    let __v_32: G = __loaded[8];
+    let __v_33: G = __loaded[9];
+    match __v_24.as_canonical_u64() {
+      1u64 => {
+        let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } else { aiur_fn_4(__args, record, io_buffer, __cu)? } };
+        let __v_34: G = __r_arr[0];
+        match __v_34.as_canonical_u64() {
+          1u64 => {
+            let __v_35: G = G::from_u64(1);
+            let __v_36: G = G::from_u64(1);
+            let __v_37: G = { let __values: [G; 10] = [__v_35, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36]; 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_242] = [__v_37];
+            record.function_queries[242].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          0u64 => {
+            let __v_35: G = G::from_u64(0);
+            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 = { let __values: [G; 10] = [__v_35, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_38]; 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_242] = [__v_39];
+            record.function_queries[242].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_34.as_canonical_u64()));
+          },
+        }
+      },
+      _ => {
+        let __v_34: G = G::from_u64(0);
+        let __v_35: G = { let __values: [G; 10] = [__v_34, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_23]; 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_242] = [__v_35];
+        record.function_queries[242].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+    }
   })
 }
 
-const INPUT_SIZE_334: usize = 3;
-const IN_334: usize = 3;
-const OUT_334: usize = 2;
-fn aiur_fn_334(
-  inp: [G; IN_334],
+const INPUT_SIZE_243: usize = 1;
+const IN_243: usize = 1;
+const OUT_243: usize = 1;
+fn aiur_fn_243(
+  inp: [G; IN_243],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_334], ExecError> {
+) -> Result<[G; OUT_243], 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_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_3: G = __loaded[0];
-    let __v_4: G = __loaded[1];
-    let __v_5: G = __loaded[2];
-    match __v_3.as_canonical_u64() {
+    let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; 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: 9 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 9] = __args[..9].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];
+    match __v_1.as_canonical_u64() {
+      0u64 => {
+        let __v_10: G = G::from_u64(0);
+        let __v_11: G = G::from_u64(0);
+        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_243] = [__v_12];
+        record.function_queries[243].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
       1u64 => {
-        let __v_6: G = G::from_u64(0);
-        let __v_7: G = G::from_u64(0);
-        let __ret: [G; OUT_334] = [__v_6, __v_7];
-        record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __v_10: G = G::from_u64(1);
+        let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } else { aiur_fn_243(__args, record, io_buffer, __cu)? } };
+        let __v_11: G = __r_arr[0];
+        let __v_12: G = G::from_u64(0);
+        let __v_13: G = { let __values: [G; 3] = [__v_10, __v_11, __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 __ret: [G; OUT_243] = [__v_13];
+        record.function_queries[243].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_6: G = __r_arr[0];
-        match __v_6.as_canonical_u64() {
-          1u64 => {
-            let __v_7: G = G::from_u64(1);
-            let __ret: [G; OUT_334] = [__v_7, __v_2];
-            record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          0u64 => {
-            let __v_7: G = G::from_u64(1);
-            let __v_8: G = (__v_2 + __v_7);
-            let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_0, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } else { aiur_fn_334(__args, record, io_buffer, __cu)? } };
-            let __v_9: G = __r_arr[0];
-            let __v_10: G = __r_arr[1];
-            let __ret: [G; OUT_334] = [__v_9, __v_10];
-            record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64()));
-          },
-        }
+      2u64 => {
+        let __v_10: G = G::from_u64(2);
+        let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } else { aiur_fn_243(__args, record, io_buffer, __cu)? } };
+        let __v_11: G = __r_arr[0];
+        let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } else { aiur_fn_243(__args, record, io_buffer, __cu)? } };
+        let __v_12: G = __r_arr[0];
+        let __v_13: G = { let __values: [G; 3] = [__v_10, __v_11, __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 __ret: [G; OUT_243] = [__v_13];
+        record.function_queries[243].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      3u64 => {
+        let __v_10: G = G::from_u64(3);
+        let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } else { aiur_fn_243(__args, record, io_buffer, __cu)? } };
+        let __v_11: G = __r_arr[0];
+        let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } else { aiur_fn_243(__args, record, io_buffer, __cu)? } };
+        let __v_12: G = __r_arr[0];
+        let __v_13: G = { let __values: [G; 3] = [__v_10, __v_11, __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 __ret: [G; OUT_243] = [__v_13];
+        record.function_queries[243].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      4u64 => {
+        let __v_10: G = G::from_u64(4);
+        let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } else { aiur_fn_15(__args, record, io_buffer, __cu)? } };
+        let __v_11: G = __r_arr[0];
+        let __v_12: G = G::from_u64(0);
+        let __v_13: G = { let __values: [G; 3] = [__v_10, __v_11, __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 __ret: [G; OUT_243] = [__v_13];
+        record.function_queries[243].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_335: usize = 2;
-const IN_335: usize = 2;
-const OUT_335: usize = 1;
-fn aiur_fn_335(
-  inp: [G; IN_335],
+const INPUT_SIZE_244: usize = 2;
+const IN_244: usize = 2;
+const OUT_244: usize = 1;
+fn aiur_fn_244(
+  inp: [G; IN_244],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_335], ExecError> {
+) -> Result<[G; OUT_244], 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 __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() {
-      7u64 => {
-        match __v_3.as_canonical_u64() {
-          0u64 => {
-            let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } else { aiur_fn_272(__args, record, io_buffer, __cu)? } };
-            let __v_6: G = __r_arr[0];
-            let __v_7: G = G::from_u64(0);
-            let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_6, __v_1, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } else { aiur_fn_334(__args, record, io_buffer, __cu)? } };
-            let __v_8: G = __r_arr[0];
-            let __v_9: G = __r_arr[1];
-            let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[273].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_273] = unsafe { *(result.output.as_ptr() as *const [G; OUT_273]) }; __ret } else { aiur_fn_273(__args, record, io_buffer, __cu)? } };
-            let __v_10: G = __r_arr[0];
-            let __v_11: G = G::from_u64(0);
-            let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_10, __v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } else { aiur_fn_334(__args, record, io_buffer, __cu)? } };
-            let __v_12: G = __r_arr[0];
-            let __v_13: G = __r_arr[1];
-            match __v_8.as_canonical_u64() {
-              1u64 => {
-                match __v_12.as_canonical_u64() {
-                  1u64 => {
-                    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_14: G = __loaded[0];
-                    let __v_15: G = __loaded[1];
-                    let __v_16: G = __loaded[2];
-                    let __v_17: G = __loaded[3];
-                    let __v_18: G = __loaded[4];
-                    let __v_19: G = __loaded[5];
-                    let __v_20: G = __loaded[6];
-                    let __v_21: G = __loaded[7];
-                    let __v_22: G = __loaded[8];
-                    let __v_23: G = __loaded[9];
-                    match __v_14.as_canonical_u64() {
-                      1u64 => {
-                        let __v_24: G = G::from_u64(2);
-                        let __v_25: G = G::from_u64(1);
-                        let __v_26: G = G::from_u64(1);
-                        let __v_27: G = { let __values: [G; 3] = [__v_25, __v_26, __v_26]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                        let __v_28: G = G::from_u64(0);
-                        let __v_29: G = { let __values: [G; 4] = [__v_24, __v_9, __v_27, __v_28]; 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_335] = [__v_29];
-                        record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                        return Ok(__ret);
-                      },
-                      0u64 => {
-                        let __v_24: G = G::from_u64(7);
-                        let __v_25: G = G::from_u64(0);
-                        let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } };
-                        let __v_26: G = __r_arr[0];
-                        let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } };
-                        let __v_27: G = __r_arr[0];
-                        let __v_28: G = G::from_u64(0);
-                        let __v_29: G = { let __values: [G; 4] = [__v_24, __v_25, __v_27, __v_28]; 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_30: G = G::from_u64(2);
-                        let __v_31: G = G::from_u64(1);
-                        let __v_32: G = G::from_u64(1);
-                        let __v_33: G = { let __values: [G; 3] = [__v_31, __v_32, __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 = G::from_u64(0);
-                        let __v_35: G = { let __values: [G; 4] = [__v_30, __v_13, __v_33, __v_34]; 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_36: G = G::from_u64(3);
-                        let __v_37: G = G::from_u64(0);
-                        let __v_38: G = { let __values: [G; 4] = [__v_36, __v_35, __v_29, __v_37]; 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_335] = [__v_38];
-                        record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                        return Ok(__ret);
-                      },
-                      _ => {
-                        return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64()));
-                      },
-                    }
-                  },
-                  _ => {
-                    let __ret: [G; OUT_335] = [__v_0];
-                    record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
-                }
-              },
-              _ => {
-                let __ret: [G; OUT_335] = [__v_0];
-                record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-            }
-          },
-          _ => {
-            let __ret: [G; OUT_335] = [__v_0];
-            record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-        }
+      1u64 => {
+        let __v_12: G = G::from_u64(1);
+        let __v_13: G = G::from_u64(1);
+        let __v_14: G = { let __values: [G; 3] = [__v_12, __v_13, __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 __ret: [G; OUT_244] = [__v_14];
+        record.function_queries[244].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
-      _ => {
-        let __ret: [G; OUT_335] = [__v_0];
-        record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+      0u64 => {
+        let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } else { aiur_fn_15(__args, record, io_buffer, __cu)? } };
+        let __v_12: G = __r_arr[0];
+        let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } };
+        let __v_13: G = __r_arr[0];
+        let __v_14: G = G::from_u64(0);
+        let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } else { aiur_fn_243(__args, record, io_buffer, __cu)? } };
+        let __v_15: G = __r_arr[0];
+        let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } else { aiur_fn_244(__args, record, io_buffer, __cu)? } };
+        let __v_16: G = __r_arr[0];
+        let __v_17: G = { let __values: [G; 3] = [__v_14, __v_15, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_244] = [__v_17];
+        record.function_queries[244].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
     }
   })
 }
 
-const INPUT_SIZE_336: usize = 2;
-const IN_336: usize = 2;
-const OUT_336: usize = 2;
-fn aiur_fn_336(
-  inp: [G; IN_336],
+const INPUT_SIZE_245: usize = 5;
+const IN_245: usize = 5;
+const OUT_245: usize = 1;
+fn aiur_fn_245(
+  inp: [G; IN_245],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_336], ExecError> {
+) -> Result<[G; OUT_245], 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() {
-      7u64 => {
-        match __v_3.as_canonical_u64() {
-          0u64 => {
-            let __v_6: G = G::from_u64(1);
-            let __ret: [G; OUT_336] = [__v_6, __v_4];
-            record.function_queries[336].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(1);
-            let __v_9: G = { let __values: [G; 10] = [__v_7, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8]; 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_336] = [__v_6, __v_9];
-            record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-        }
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; 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: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].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];
+    match __v_5.as_canonical_u64() {
+      0u64 => {
+        let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } else { aiur_fn_15(__args, record, io_buffer, __cu)? } };
+        let __v_23: G = __r_arr[0];
+        let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_4, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } };
+        let __v_24: G = __r_arr[0];
+        let __v_25: G = G::from_u64(1);
+        let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } else { aiur_fn_243(__args, record, io_buffer, __cu)? } };
+        let __v_26: G = __r_arr[0];
+        let __v_27: G = G::from_u64(0);
+        let __v_28: G = { let __values: [G; 4] = [__v_25, __v_26, __v_27, __v_27]; 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_245] = [__v_28];
+        record.function_queries[245].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      1u64 => {
+        let __v_23: G = G::from_u64(0);
+        let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } else { aiur_fn_15(__args, record, io_buffer, __cu)? } };
+        let __v_24: G = __r_arr[0];
+        let __v_25: G = G::from_u64(0);
+        let __v_26: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_25]; 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_245] = [__v_26];
+        record.function_queries[245].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-        let __v_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } else { aiur_fn_272(__args, record, io_buffer, __cu)? } };
-        let __v_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_8: G = __r_arr[0];
-        match __v_8.as_canonical_u64() {
-          1u64 => {
-            let __v_9: G = G::from_u64(1);
-            let __v_10: G = G::from_u64(1);
-            let __v_11: G = G::from_u64(1);
-            let __v_12: G = { let __values: [G; 10] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; 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_336] = [__v_9, __v_12];
-            record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
+        let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } else { aiur_fn_15(__args, record, io_buffer, __cu)? } };
+        let __v_23: G = __r_arr[0];
+        let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } };
+        let __v_24: G = __r_arr[0];
+        let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_14, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } else { aiur_fn_244(__args, record, io_buffer, __cu)? } };
+        let __v_25: G = __r_arr[0];
+        let __v_26: G = G::from_u64(2);
+        let __v_27: G = G::from_u64(0);
+        let __v_28: G = { let __values: [G; 4] = [__v_26, __v_24, __v_25, __v_27]; 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_245] = [__v_28];
+        record.function_queries[245].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      3u64 => {
+        let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } else { aiur_fn_15(__args, record, io_buffer, __cu)? } };
+        let __v_23: G = __r_arr[0];
+        let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_3, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } };
+        let __v_24: G = __r_arr[0];
+        let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_14, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } else { aiur_fn_244(__args, record, io_buffer, __cu)? } };
+        let __v_25: G = __r_arr[0];
+        let __v_26: G = G::from_u64(2);
+        let __v_27: G = G::from_u64(0);
+        let __v_28: G = { let __values: [G; 4] = [__v_26, __v_24, __v_25, __v_27]; 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_245] = [__v_28];
+        record.function_queries[245].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      4u64 => {
+        let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } else { aiur_fn_15(__args, record, io_buffer, __cu)? } };
+        let __v_23: G = __r_arr[0];
+        let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } };
+        let __v_24: G = __r_arr[0];
+        let __v_25: G = G::from_u64(8);
+        let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } else { aiur_fn_15(__args, record, io_buffer, __cu)? } };
+        let __v_26: G = __r_arr[0];
+        let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_22, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } else { aiur_fn_245(__args, record, io_buffer, __cu)? } };
+        let __v_27: G = __r_arr[0];
+        let __v_28: G = { let __values: [G; 4] = [__v_25, __v_24, __v_26, __v_27]; 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_245] = [__v_28];
+        record.function_queries[245].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      5u64 => {
+        let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } else { aiur_fn_15(__args, record, io_buffer, __cu)? } };
+        let __v_23: G = __r_arr[0];
+        let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } };
+        let __v_24: G = __r_arr[0];
+        let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[257].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_257] = unsafe { *(result.output.as_ptr() as *const [G; OUT_257]) }; __ret } else { aiur_fn_257(__args, record, io_buffer, __cu)? } };
+        let __v_25: G = __r_arr[0];
+        let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { 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_26: G = G::from_u64(7);
+        let __v_27: G = G::from_u64(1);
+        let __v_28: G = G::from_u64(0);
+        let __v_29: G = { let __values: [G; 4] = [__v_26, __v_27, __v_25, __v_28]; 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_245] = [__v_29];
+        record.function_queries[245].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      6u64 => {
+        let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } else { aiur_fn_15(__args, record, io_buffer, __cu)? } };
+        let __v_23: G = __r_arr[0];
+        let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } };
+        let __v_24: G = __r_arr[0];
+        let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[257].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_257] = unsafe { *(result.output.as_ptr() as *const [G; OUT_257]) }; __ret } else { aiur_fn_257(__args, record, io_buffer, __cu)? } };
+        let __v_25: G = __r_arr[0];
+        let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } else { aiur_fn_242(__args, record, io_buffer, __cu)? } };
+        let __v_26: G = __r_arr[0];
+        let __v_27: G = G::from_u64(7);
+        let __v_28: G = G::from_u64(0);
+        let __v_29: G = G::from_u64(0);
+        let __v_30: G = { let __values: [G; 4] = [__v_27, __v_28, __v_26, __v_29]; 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_245] = [__v_30];
+        record.function_queries[245].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      7u64 => {
+        let __v_23: G = G::from_u64(3);
+        let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_6, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } else { aiur_fn_245(__args, record, io_buffer, __cu)? } };
+        let __v_24: G = __r_arr[0];
+        let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } else { aiur_fn_245(__args, record, io_buffer, __cu)? } };
+        let __v_25: G = __r_arr[0];
+        let __v_26: G = G::from_u64(0);
+        let __v_27: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_26]; 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_245] = [__v_27];
+        record.function_queries[245].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      8u64 => {
+        let __v_23: G = G::from_u64(4);
+        let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_6, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } else { aiur_fn_245(__args, record, io_buffer, __cu)? } };
+        let __v_24: G = __r_arr[0];
+        let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } else { aiur_fn_245(__args, record, io_buffer, __cu)? } };
+        let __v_25: G = __r_arr[0];
+        let __v_26: G = G::from_u64(0);
+        let __v_27: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_26]; 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_245] = [__v_27];
+        record.function_queries[245].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      9u64 => {
+        let __v_23: G = G::from_u64(5);
+        let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_6, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } else { aiur_fn_245(__args, record, io_buffer, __cu)? } };
+        let __v_24: G = __r_arr[0];
+        let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } else { aiur_fn_245(__args, record, io_buffer, __cu)? } };
+        let __v_25: G = __r_arr[0];
+        let __v_26: G = G::from_u64(0);
+        let __v_27: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_26]; 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_245] = [__v_27];
+        record.function_queries[245].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      10u64 => {
+        let __v_23: G = G::from_u64(6);
+        let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_14, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } else { aiur_fn_245(__args, record, io_buffer, __cu)? } };
+        let __v_24: G = __r_arr[0];
+        let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_15, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } else { aiur_fn_245(__args, record, io_buffer, __cu)? } };
+        let __v_25: G = __r_arr[0];
+        let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_16, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } else { aiur_fn_245(__args, record, io_buffer, __cu)? } };
+        let __v_26: G = __r_arr[0];
+        let __v_27: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_26]; 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_245] = [__v_27];
+        record.function_queries[245].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      11u64 => {
+        let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } else { aiur_fn_15(__args, record, io_buffer, __cu)? } };
+        let __v_23: G = __r_arr[0];
+        let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_1, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } };
+        let __v_24: 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_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 __v_9: G = G::from_u64(0);
-            let __v_10: G = G::from_u64(1);
-            let __v_11: G = G::from_u64(1);
-            let __v_12: G = { let __values: [G; 10] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; 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_336] = [__v_9, __v_12];
-            record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_26, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } else { aiur_fn_245(__args, record, io_buffer, __cu)? } };
+            let __v_28: G = __r_arr[0];
+            let __ret: [G; OUT_245] = [__v_28];
+            record.function_queries[245].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64()));
+            return Err(ExecError::MatchNoCase(__v_25.as_canonical_u64()));
           },
         }
       },
-      3u64 => {
-        let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_3, __v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } };
-        let __v_6: G = __r_arr[0];
-        let __v_7: G = __r_arr[1];
-        let __ret: [G; OUT_336] = [__v_6, __v_7];
-        record.function_queries[336].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(1);
-        let __v_9: G = { let __values: [G; 10] = [__v_7, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8]; 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_336] = [__v_6, __v_9];
-        record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
+        return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_337: usize = 3;
-const IN_337: usize = 3;
-const OUT_337: usize = 2;
-fn aiur_fn_337(
-  inp: [G; IN_337],
+const INPUT_SIZE_246: usize = 17;
+const IN_246: usize = 17;
+const OUT_246: usize = 12;
+fn aiur_fn_246(
+  inp: [G; IN_246],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_337], ExecError> {
+) -> Result<[G; OUT_246], 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; 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_3: G = __loaded[0];
-    let __v_4: G = __loaded[1];
-    let __v_5: G = __loaded[2];
-    let __v_6: G = __loaded[3];
-    match __v_3.as_canonical_u64() {
-      2u64 => {
-        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-        let __v_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[273].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_273] = unsafe { *(result.output.as_ptr() as *const [G; OUT_273]) }; __ret } else { aiur_fn_273(__args, record, io_buffer, __cu)? } };
-        let __v_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_9: G = __r_arr[0];
-        match __v_9.as_canonical_u64() {
+    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];
+    match __v_0.as_canonical_u64() {
+      _ => {
+        let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_10, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } else { aiur_fn_245(__args, record, io_buffer, __cu)? } };
+        let __v_17: G = __r_arr[0];
+        let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } else { aiur_fn_245(__args, record, io_buffer, __cu)? } };
+        let __v_18: G = __r_arr[0];
+        let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } else { aiur_fn_15(__args, record, io_buffer, __cu)? } };
+        let __v_19: G = __r_arr[0];
+        match __v_0.as_canonical_u64() {
+          0u64 => {
+            let __v_20: G = G::from_u64(1);
+            let __v_21: G = G::from_u64(0);
+            let __ret: [G; OUT_246] = [__v_20, __v_19, __v_17, __v_18, __v_1, __v_16, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21];
+            record.function_queries[246].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
           1u64 => {
-            let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } else { aiur_fn_336(__args, record, io_buffer, __cu)? } };
-            let __v_10: G = __r_arr[0];
-            let __v_11: G = __r_arr[1];
-            match __v_10.as_canonical_u64() {
-              1u64 => {
-                let __v_12: G = G::from_u64(1);
-                let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[304].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_304] = unsafe { *(result.output.as_ptr() as *const [G; OUT_304]) }; __ret } else { aiur_fn_304(__args, record, io_buffer, __cu)? } };
-                let __v_13: G = __r_arr[0];
-                let __ret: [G; OUT_337] = [__v_12, __v_13];
-                record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              _ => {
-                let __v_12: G = G::from_u64(0);
-                let __v_13: G = G::from_u64(1);
-                let __v_14: G = G::from_u64(1);
-                let __v_15: G = { let __values: [G; 10] = [__v_13, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14]; 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_337] = [__v_12, __v_15];
-                record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-            }
+            let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_1.as_canonical_u64() {
+  0u64 => {
+    let __v_20: G = G::from_u64(1);
+    break '__mc_0 [__v_20];
+  },
+  _ => {
+    let __v_20: G = G::from_u64(0);
+    break '__mc_0 [__v_20];
+  },
+}
+ };
+            let __v_20: G = __mc_out___mc_0[0];
+            let __v_21: G = G::from_u64(3);
+            let __v_22: G = G::from_u64(0);
+            let __ret: [G; OUT_246] = [__v_21, __v_19, __v_17, __v_18, __v_20, __v_22, __v_22, __v_22, __v_22, __v_22, __v_22, __v_22];
+            record.function_queries[246].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
           },
-          0u64 => {
-            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 = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; 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_337] = [__v_10, __v_13];
-            record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+          2u64 => {
+            let __v_20: G = G::from_u64(2);
+            let __v_21: G = G::from_u64(0);
+            let __ret: [G; OUT_246] = [__v_20, __v_19, __v_17, __v_18, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21];
+            record.function_queries[246].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64()));
+            return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64()));
           },
         }
       },
-      _ => {
-        let __v_7: G = G::from_u64(0);
-        let __v_8: G = G::from_u64(1);
-        let __v_9: G = G::from_u64(1);
-        let __v_10: G = { let __values: [G; 10] = [__v_8, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9]; 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_337] = [__v_7, __v_10];
-        record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
     }
   })
 }
 
-const INPUT_SIZE_338: usize = 1;
-const IN_338: usize = 1;
-const OUT_338: usize = 1;
-fn aiur_fn_338(
-  inp: [G; IN_338],
+const INPUT_SIZE_247: usize = 14;
+const IN_247: usize = 14;
+const OUT_247: usize = 12;
+fn aiur_fn_247(
+  inp: [G; IN_247],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_338], ExecError> {
+) -> Result<[G; OUT_247], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __v_1: G = G::from_u64(7);
-    let __v_2: G = G::from_u64(0);
-    let __v_3: G = G::from_u64(0);
-    let __v_4: G = { let __values: [G; 4] = [__v_1, __v_2, __v_0, __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_338] = [__v_4];
-    record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
+    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];
+    match __v_0.as_canonical_u64() {
+      _ => {
+        let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } else { aiur_fn_245(__args, record, io_buffer, __cu)? } };
+        let __v_14: G = __r_arr[0];
+        let __v_15: G = G::from_u64(0);
+        let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__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[15].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } else { aiur_fn_15(__args, record, io_buffer, __cu)? } };
+        let __v_16: G = __r_arr[0];
+        let __v_17: G = G::from_u64(0);
+        let __ret: [G; OUT_247] = [__v_15, __v_16, __v_14, __v_0, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17];
+        record.function_queries[247].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+    }
   })
 }
 
-const INPUT_SIZE_339: usize = 4;
-const IN_339: usize = 4;
-const OUT_339: usize = 2;
-fn aiur_fn_339(
-  inp: [G; IN_339],
+const INPUT_SIZE_248: usize = 14;
+const IN_248: usize = 14;
+const OUT_248: usize = 12;
+fn aiur_fn_248(
+  inp: [G; IN_248],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_339], ExecError> {
+) -> Result<[G; OUT_248], 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_320] = { let __args: [G; IN_320] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } else { aiur_fn_320(__args, record, io_buffer, __cu)? } };
-    let __v_4: G = __r_arr[0];
-    match __v_4.as_canonical_u64() {
-      1u64 => {
-        let __v_5: G = G::from_u64(1);
-        let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[427].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_427] = unsafe { *(result.output.as_ptr() as *const [G; OUT_427]) }; __ret } else { aiur_fn_427(__args, record, io_buffer, __cu)? } };
-        let __v_6: G = __r_arr[0];
-        let __ret: [G; OUT_339] = [__v_5, __v_6];
-        record.function_queries[339].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __r_arr: [G; OUT_275] = { let __args: [G; IN_275] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[275].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_275] = unsafe { *(result.output.as_ptr() as *const [G; OUT_275]) }; __ret } else { aiur_fn_275(__args, record, io_buffer, __cu)? } };
-        let __v_5: G = __r_arr[0];
-        let __v_6: G = G::from_u64(0);
-        let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_5, __v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } else { aiur_fn_334(__args, record, io_buffer, __cu)? } };
-        let __v_7: G = __r_arr[0];
-        let __v_8: G = __r_arr[1];
-        match __v_7.as_canonical_u64() {
-          0u64 => {
-            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 = { let __values: [G; 4] = [__v_10, __v_11, __v_12, __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_339] = [__v_9, __v_13];
-            record.function_queries[339].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          1u64 => {
-            let __v_9: G = G::from_u64(2);
-            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 __v_13: G = G::from_u64(0);
-            let __v_14: G = { let __values: [G; 4] = [__v_9, __v_8, __v_12, __v_13]; 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_15: G = G::from_u64(3);
-            let __v_16: G = G::from_u64(3);
-            let __v_17: G = G::from_u64(0);
-            let __v_18: G = { let __values: [G; 4] = [__v_16, __v_14, __v_0, __v_17]; 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_338] = { let __args: [G; IN_338] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } else { aiur_fn_338(__args, record, io_buffer, __cu)? } };
-            let __v_19: G = __r_arr[0];
-            let __v_20: G = G::from_u64(0);
-            let __v_21: G = { let __values: [G; 4] = [__v_15, __v_18, __v_19, __v_20]; 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_22: G = G::from_u64(1);
-            let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_21, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[427].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_427] = unsafe { *(result.output.as_ptr() as *const [G; OUT_427]) }; __ret } else { aiur_fn_427(__args, record, io_buffer, __cu)? } };
-            let __v_23: G = __r_arr[0];
-            let __ret: [G; OUT_339] = [__v_22, __v_23];
-            record.function_queries[339].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64()));
-          },
-        }
-      },
+    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];
+    match __v_0.as_canonical_u64() {
       _ => {
-        return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
+        let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } else { aiur_fn_245(__args, record, io_buffer, __cu)? } };
+        let __v_14: G = __r_arr[0];
+        let __v_15: G = G::from_u64(4);
+        let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__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[15].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } else { aiur_fn_15(__args, record, io_buffer, __cu)? } };
+        let __v_16: G = __r_arr[0];
+        let __v_17: G = G::from_u64(0);
+        let __ret: [G; OUT_248] = [__v_15, __v_16, __v_14, __v_0, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17];
+        record.function_queries[248].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_340: usize = 1;
-const IN_340: usize = 1;
-const OUT_340: usize = 1;
-fn aiur_fn_340(
-  inp: [G; IN_340],
+const INPUT_SIZE_249: usize = 1;
+const IN_249: usize = 1;
+const OUT_249: usize = 1;
+fn aiur_fn_249(
+  inp: [G; IN_249],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_340], ExecError> {
+) -> Result<[G; OUT_249], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } else { aiur_fn_341(__args, record, io_buffer, __cu)? } };
-    let __v_1: G = __r_arr[0];
+    let __loaded: [G; 36] = { let __mq = record.memory_queries.get_mut(&36).ok_or(ExecError::InvalidMemorySize(36))?; 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: 36 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 36] = __args[..36].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 __v_35: G = __loaded[34];
+    let __v_36: G = __loaded[35];
     match __v_1.as_canonical_u64() {
       1u64 => {
-        let __v_2: G = G::from_u64(1);
-        let __ret: [G; OUT_340] = [__v_2];
-        record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __v_37: G = G::from_u64(0);
+        let __ret: [G; OUT_249] = [__v_37];
+        record.function_queries[249].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } };
-        let __v_2: G = __r_arr[0];
-        match __v_2.as_canonical_u64() {
-          1u64 => {
-            let __v_3: G = G::from_u64(2);
-            let __ret: [G; OUT_340] = [__v_3];
-            record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          0u64 => {
-            let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } else { aiur_fn_343(__args, record, io_buffer, __cu)? } };
-            let __v_3: G = __r_arr[0];
-            match __v_3.as_canonical_u64() {
-              1u64 => {
-                let __v_4: G = G::from_u64(3);
-                let __ret: [G; OUT_340] = [__v_4];
-                record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              0u64 => {
-                let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[344].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_344] = unsafe { *(result.output.as_ptr() as *const [G; OUT_344]) }; __ret } else { aiur_fn_344(__args, record, io_buffer, __cu)? } };
-                let __v_4: G = __r_arr[0];
-                match __v_4.as_canonical_u64() {
-                  1u64 => {
-                    let __v_5: G = G::from_u64(4);
-                    let __ret: [G; OUT_340] = [__v_5];
-                    record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
-                  0u64 => {
-                    let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[345].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_345] = unsafe { *(result.output.as_ptr() as *const [G; OUT_345]) }; __ret } else { aiur_fn_345(__args, record, io_buffer, __cu)? } };
-                    let __v_5: G = __r_arr[0];
-                    match __v_5.as_canonical_u64() {
-                      1u64 => {
-                        let __v_6: G = G::from_u64(5);
-                        let __ret: [G; OUT_340] = [__v_6];
-                        record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                        return Ok(__ret);
-                      },
-                      0u64 => {
-                        let __v_6: G = G::from_u64(0);
-                        let __ret: [G; OUT_340] = [__v_6];
-                        record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                        return Ok(__ret);
-                      },
-                      _ => {
-                        return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
-                      },
-                    }
-                  },
-                  _ => {
-                    return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
-                  },
-                }
-              },
-              _ => {
-                return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
-              },
-            }
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-          },
-        }
+        let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[249].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_249] = unsafe { *(result.output.as_ptr() as *const [G; OUT_249]) }; __ret } else { aiur_fn_249(__args, record, io_buffer, __cu)? } };
+        let __v_37: G = __r_arr[0];
+        let __v_38: G = G::from_u64(1);
+        let __v_39: G = (__v_37 + __v_38);
+        let __ret: [G; OUT_249] = [__v_39];
+        record.function_queries[249].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
       _ => {
         return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
@@ -30592,286 +23378,104 @@ fn aiur_fn_340(
   })
 }
 
-const INPUT_SIZE_341: usize = 1;
-const IN_341: usize = 1;
-const OUT_341: usize = 1;
-fn aiur_fn_341(
-  inp: [G; IN_341],
+const INPUT_SIZE_250: usize = 2;
+const IN_250: usize = 2;
+const OUT_250: usize = 34;
+fn aiur_fn_250(
+  inp: [G; IN_250],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_341], ExecError> {
+) -> Result<[G; OUT_250], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[273].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_273] = unsafe { *(result.output.as_ptr() as *const [G; OUT_273]) }; __ret } else { aiur_fn_273(__args, record, io_buffer, __cu)? } };
-    let __v_1: G = __r_arr[0];
-    let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_2: G = __r_arr[0];
+    let __v_1: G = inp[1];
+    let __loaded: [G; 36] = { let __mq = record.memory_queries.get_mut(&36).ok_or(ExecError::InvalidMemorySize(36))?; 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: 36 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 36] = __args[..36].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];
+    let __v_12: G = __loaded[10];
+    let __v_13: G = __loaded[11];
+    let __v_14: G = __loaded[12];
+    let __v_15: G = __loaded[13];
+    let __v_16: G = __loaded[14];
+    let __v_17: G = __loaded[15];
+    let __v_18: G = __loaded[16];
+    let __v_19: G = __loaded[17];
+    let __v_20: G = __loaded[18];
+    let __v_21: G = __loaded[19];
+    let __v_22: G = __loaded[20];
+    let __v_23: G = __loaded[21];
+    let __v_24: G = __loaded[22];
+    let __v_25: G = __loaded[23];
+    let __v_26: G = __loaded[24];
+    let __v_27: G = __loaded[25];
+    let __v_28: G = __loaded[26];
+    let __v_29: G = __loaded[27];
+    let __v_30: G = __loaded[28];
+    let __v_31: G = __loaded[29];
+    let __v_32: G = __loaded[30];
+    let __v_33: G = __loaded[31];
+    let __v_34: G = __loaded[32];
+    let __v_35: G = __loaded[33];
+    let __v_36: G = __loaded[34];
+    let __v_37: G = __loaded[35];
     match __v_2.as_canonical_u64() {
-      1u64 => {
-        let __v_3: G = G::from_u64(1);
-        let __ret: [G; OUT_341] = [__v_3];
-        record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
       0u64 => {
-        let __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[274].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_274] = unsafe { *(result.output.as_ptr() as *const [G; OUT_274]) }; __ret } else { aiur_fn_274(__args, record, io_buffer, __cu)? } };
-        let __v_3: G = __r_arr[0];
-        let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_4: G = __r_arr[0];
-        match __v_4.as_canonical_u64() {
-          1u64 => {
-            let __v_5: G = G::from_u64(1);
-            let __ret: [G; OUT_341] = [__v_5];
-            record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
+        match __v_1.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_275] = { let __args: [G; IN_275] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[275].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_275] = unsafe { *(result.output.as_ptr() as *const [G; OUT_275]) }; __ret } else { aiur_fn_275(__args, record, io_buffer, __cu)? } };
-            let __v_5: G = __r_arr[0];
-            let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_6: G = __r_arr[0];
-            match __v_6.as_canonical_u64() {
-              1u64 => {
-                let __v_7: G = G::from_u64(1);
-                let __ret: [G; OUT_341] = [__v_7];
-                record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              0u64 => {
-                let __r_arr: [G; OUT_276] = { let __args: [G; IN_276] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[276].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_276] = unsafe { *(result.output.as_ptr() as *const [G; OUT_276]) }; __ret } else { aiur_fn_276(__args, record, io_buffer, __cu)? } };
-                let __v_7: G = __r_arr[0];
-                let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_8: G = __r_arr[0];
-                match __v_8.as_canonical_u64() {
-                  1u64 => {
-                    let __v_9: G = G::from_u64(1);
-                    let __ret: [G; OUT_341] = [__v_9];
-                    record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
-                  0u64 => {
-                    let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[277].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_277] = unsafe { *(result.output.as_ptr() as *const [G; OUT_277]) }; __ret } else { aiur_fn_277(__args, record, io_buffer, __cu)? } };
-                    let __v_9: G = __r_arr[0];
-                    let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_10: G = __r_arr[0];
-                    match __v_10.as_canonical_u64() {
-                      1u64 => {
-                        let __v_11: G = G::from_u64(1);
-                        let __ret: [G; OUT_341] = [__v_11];
-                        record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                        return Ok(__ret);
-                      },
-                      0u64 => {
-                        let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[281].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_281] = unsafe { *(result.output.as_ptr() as *const [G; OUT_281]) }; __ret } else { aiur_fn_281(__args, record, io_buffer, __cu)? } };
-                        let __v_11: G = __r_arr[0];
-                        let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_12: G = __r_arr[0];
-                        match __v_12.as_canonical_u64() {
-                          1u64 => {
-                            let __v_13: G = G::from_u64(1);
-                            let __ret: [G; OUT_341] = [__v_13];
-                            record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                            return Ok(__ret);
-                          },
-                          0u64 => {
-                            let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[280].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_280] = unsafe { *(result.output.as_ptr() as *const [G; OUT_280]) }; __ret } else { aiur_fn_280(__args, record, io_buffer, __cu)? } };
-                            let __v_13: G = __r_arr[0];
-                            let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_14: G = __r_arr[0];
-                            match __v_14.as_canonical_u64() {
-                              1u64 => {
-                                let __v_15: G = G::from_u64(1);
-                                let __ret: [G; OUT_341] = [__v_15];
-                                record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                return Ok(__ret);
-                              },
-                              0u64 => {
-                                let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } else { aiur_fn_278(__args, record, io_buffer, __cu)? } };
-                                let __v_15: G = __r_arr[0];
-                                let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_16: G = __r_arr[0];
-                                match __v_16.as_canonical_u64() {
-                                  1u64 => {
-                                    let __v_17: G = G::from_u64(1);
-                                    let __ret: [G; OUT_341] = [__v_17];
-                                    record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                    return Ok(__ret);
-                                  },
-                                  0u64 => {
-                                    let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } else { aiur_fn_279(__args, record, io_buffer, __cu)? } };
-                                    let __v_17: G = __r_arr[0];
-                                    let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_18: G = __r_arr[0];
-                                    match __v_18.as_canonical_u64() {
-                                      1u64 => {
-                                        let __v_19: G = G::from_u64(1);
-                                        let __ret: [G; OUT_341] = [__v_19];
-                                        record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                        return Ok(__ret);
-                                      },
-                                      0u64 => {
-                                        let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } else { aiur_fn_287(__args, record, io_buffer, __cu)? } };
-                                        let __v_19: G = __r_arr[0];
-                                        let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_20: G = __r_arr[0];
-                                        match __v_20.as_canonical_u64() {
-                                          1u64 => {
-                                            let __v_21: G = G::from_u64(1);
-                                            let __ret: [G; OUT_341] = [__v_21];
-                                            record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                            return Ok(__ret);
-                                          },
-                                          0u64 => {
-                                            let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[288].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_288] = unsafe { *(result.output.as_ptr() as *const [G; OUT_288]) }; __ret } else { aiur_fn_288(__args, record, io_buffer, __cu)? } };
-                                            let __v_21: G = __r_arr[0];
-                                            let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_22: G = __r_arr[0];
-                                            match __v_22.as_canonical_u64() {
-                                              1u64 => {
-                                                let __v_23: G = G::from_u64(1);
-                                                let __ret: [G; OUT_341] = [__v_23];
-                                                record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                                return Ok(__ret);
-                                              },
-                                              0u64 => {
-                                                let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } else { aiur_fn_282(__args, record, io_buffer, __cu)? } };
-                                                let __v_23: G = __r_arr[0];
-                                                let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_24: G = __r_arr[0];
-                                                match __v_24.as_canonical_u64() {
-                                                  1u64 => {
-                                                    let __v_25: G = G::from_u64(1);
-                                                    let __ret: [G; OUT_341] = [__v_25];
-                                                    record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                                    return Ok(__ret);
-                                                  },
-                                                  0u64 => {
-                                                    let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } else { aiur_fn_283(__args, record, io_buffer, __cu)? } };
-                                                    let __v_25: G = __r_arr[0];
-                                                    let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_26: G = __r_arr[0];
-                                                    match __v_26.as_canonical_u64() {
-                                                      1u64 => {
-                                                        let __v_27: G = G::from_u64(1);
-                                                        let __ret: [G; OUT_341] = [__v_27];
-                                                        record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                                        return Ok(__ret);
-                                                      },
-                                                      0u64 => {
-                                                        let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } else { aiur_fn_284(__args, record, io_buffer, __cu)? } };
-                                                        let __v_27: G = __r_arr[0];
-                                                        let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_28: G = __r_arr[0];
-                                                        match __v_28.as_canonical_u64() {
-                                                          1u64 => {
-                                                            let __v_29: G = G::from_u64(1);
-                                                            let __ret: [G; OUT_341] = [__v_29];
-                                                            record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                                            return Ok(__ret);
-                                                          },
-                                                          0u64 => {
-                                                            let __r_arr: [G; OUT_285] = { let __args: [G; IN_285] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[285].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_285] = unsafe { *(result.output.as_ptr() as *const [G; OUT_285]) }; __ret } else { aiur_fn_285(__args, record, io_buffer, __cu)? } };
-                                                            let __v_29: G = __r_arr[0];
-                                                            let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_30: G = __r_arr[0];
-                                                            match __v_30.as_canonical_u64() {
-                                                              1u64 => {
-                                                                let __v_31: G = G::from_u64(1);
-                                                                let __ret: [G; OUT_341] = [__v_31];
-                                                                record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                                                return Ok(__ret);
-                                                              },
-                                                              0u64 => {
-                                                                let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } else { aiur_fn_286(__args, record, io_buffer, __cu)? } };
-                                                                let __v_31: G = __r_arr[0];
-                                                                let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_32: G = __r_arr[0];
-                                                                match __v_32.as_canonical_u64() {
-                                                                  1u64 => {
-                                                                    let __v_33: G = G::from_u64(1);
-                                                                    let __ret: [G; OUT_341] = [__v_33];
-                                                                    record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                                                    return Ok(__ret);
-                                                                  },
-                                                                  0u64 => {
-                                                                    let __v_33: G = G::from_u64(0);
-                                                                    let __ret: [G; OUT_341] = [__v_33];
-                                                                    record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                                                    return Ok(__ret);
-                                                                  },
-                                                                  _ => {
-                                                                    return Err(ExecError::MatchNoCase(__v_32.as_canonical_u64()));
-                                                                  },
-                                                                }
-                                                              },
-                                                              _ => {
-                                                                return Err(ExecError::MatchNoCase(__v_30.as_canonical_u64()));
-                                                              },
-                                                            }
-                                                          },
-                                                          _ => {
-                                                            return Err(ExecError::MatchNoCase(__v_28.as_canonical_u64()));
-                                                          },
-                                                        }
-                                                      },
-                                                      _ => {
-                                                        return Err(ExecError::MatchNoCase(__v_26.as_canonical_u64()));
-                                                      },
-                                                    }
-                                                  },
-                                                  _ => {
-                                                    return Err(ExecError::MatchNoCase(__v_24.as_canonical_u64()));
-                                                  },
-                                                }
-                                              },
-                                              _ => {
-                                                return Err(ExecError::MatchNoCase(__v_22.as_canonical_u64()));
-                                              },
-                                            }
-                                          },
-                                          _ => {
-                                            return Err(ExecError::MatchNoCase(__v_20.as_canonical_u64()));
-                                          },
-                                        }
-                                      },
-                                      _ => {
-                                        return Err(ExecError::MatchNoCase(__v_18.as_canonical_u64()));
-                                      },
-                                    }
-                                  },
-                                  _ => {
-                                    return Err(ExecError::MatchNoCase(__v_16.as_canonical_u64()));
-                                  },
-                                }
-                              },
-                              _ => {
-                                return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64()));
-                              },
-                            }
-                          },
-                          _ => {
-                            return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64()));
-                          },
-                        }
-                      },
-                      _ => {
-                        return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64()));
-                      },
-                    }
-                  },
-                  _ => {
-                    return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64()));
-                  },
-                }
-              },
-              _ => {
-                return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64()));
-              },
-            }
+            let __ret: [G; OUT_250] = [__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_35, __v_36];
+            record.function_queries[250].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
           },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
+            let __v_38: G = G::from_u64(1);
+            let __v_39: G = (__v_1 - __v_38);
+            let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_37, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[250].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_250] = unsafe { *(result.output.as_ptr() as *const [G; OUT_250]) }; __ret } else { aiur_fn_250(__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 __v_43: G = __r_arr[3];
+            let __v_44: G = __r_arr[4];
+            let __v_45: G = __r_arr[5];
+            let __v_46: G = __r_arr[6];
+            let __v_47: G = __r_arr[7];
+            let __v_48: G = __r_arr[8];
+            let __v_49: G = __r_arr[9];
+            let __v_50: G = __r_arr[10];
+            let __v_51: G = __r_arr[11];
+            let __v_52: G = __r_arr[12];
+            let __v_53: G = __r_arr[13];
+            let __v_54: G = __r_arr[14];
+            let __v_55: G = __r_arr[15];
+            let __v_56: G = __r_arr[16];
+            let __v_57: G = __r_arr[17];
+            let __v_58: G = __r_arr[18];
+            let __v_59: G = __r_arr[19];
+            let __v_60: G = __r_arr[20];
+            let __v_61: G = __r_arr[21];
+            let __v_62: G = __r_arr[22];
+            let __v_63: G = __r_arr[23];
+            let __v_64: G = __r_arr[24];
+            let __v_65: G = __r_arr[25];
+            let __v_66: G = __r_arr[26];
+            let __v_67: G = __r_arr[27];
+            let __v_68: G = __r_arr[28];
+            let __v_69: G = __r_arr[29];
+            let __v_70: G = __r_arr[30];
+            let __v_71: G = __r_arr[31];
+            let __v_72: G = __r_arr[32];
+            let __v_73: G = __r_arr[33];
+            let __ret: [G; OUT_250] = [__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];
+            record.function_queries[250].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
           },
         }
       },
@@ -30882,848 +23486,935 @@ fn aiur_fn_341(
   })
 }
 
-const INPUT_SIZE_342: usize = 1;
-const IN_342: usize = 1;
-const OUT_342: usize = 1;
-fn aiur_fn_342(
-  inp: [G; IN_342],
+const INPUT_SIZE_251: usize = 33;
+const IN_251: usize = 33;
+const OUT_251: usize = 12;
+fn aiur_fn_251(
+  inp: [G; IN_251],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_342], ExecError> {
+) -> Result<[G; OUT_251], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } else { aiur_fn_290(__args, record, io_buffer, __cu)? } };
-    let __v_1: G = __r_arr[0];
-    let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_2: G = __r_arr[0];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
-        let __v_3: G = G::from_u64(1);
-        let __ret: [G; OUT_342] = [__v_3];
-        record.function_queries[342].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 = 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];
+    match __v_0.as_canonical_u64() {
+      _ => {
+        let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_25, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } else { aiur_fn_245(__args, record, io_buffer, __cu)? } };
+        let __v_33: G = __r_arr[0];
+        let __v_34: G = G::from_u64(5);
+        let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__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[15].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } else { aiur_fn_15(__args, record, io_buffer, __cu)? } };
+        let __v_35: G = __r_arr[0];
+        let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__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[15].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } else { aiur_fn_15(__args, record, io_buffer, __cu)? } };
+        let __v_36: G = __r_arr[0];
+        let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__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[15].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } else { aiur_fn_15(__args, record, io_buffer, __cu)? } };
+        let __v_37: G = __r_arr[0];
+        let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[249].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_249] = unsafe { *(result.output.as_ptr() as *const [G; OUT_249]) }; __ret } else { aiur_fn_249(__args, record, io_buffer, __cu)? } };
+        let __v_38: G = __r_arr[0];
+        let __v_39: G = G::from_u64(0);
+        let __ret: [G; OUT_251] = [__v_34, __v_35, __v_33, __v_36, __v_37, __v_38, __v_0, __v_27, __v_28, __v_39, __v_39, __v_39];
+        record.function_queries[251].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[293].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_293] = unsafe { *(result.output.as_ptr() as *const [G; OUT_293]) }; __ret } else { aiur_fn_293(__args, record, io_buffer, __cu)? } };
-        let __v_3: G = __r_arr[0];
-        let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_4: G = __r_arr[0];
-        match __v_4.as_canonical_u64() {
-          1u64 => {
-            let __v_5: G = G::from_u64(1);
-            let __ret: [G; OUT_342] = [__v_5];
-            record.function_queries[342].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          0u64 => {
-            let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[291].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_291] = unsafe { *(result.output.as_ptr() as *const [G; OUT_291]) }; __ret } else { aiur_fn_291(__args, record, io_buffer, __cu)? } };
-            let __v_5: G = __r_arr[0];
-            let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_6: G = __r_arr[0];
-            match __v_6.as_canonical_u64() {
-              1u64 => {
-                let __v_7: G = G::from_u64(1);
-                let __ret: [G; OUT_342] = [__v_7];
-                record.function_queries[342].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              0u64 => {
-                let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[292].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_292] = unsafe { *(result.output.as_ptr() as *const [G; OUT_292]) }; __ret } else { aiur_fn_292(__args, record, io_buffer, __cu)? } };
-                let __v_7: G = __r_arr[0];
-                let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_8: G = __r_arr[0];
-                match __v_8.as_canonical_u64() {
-                  1u64 => {
-                    let __v_9: G = G::from_u64(1);
-                    let __ret: [G; OUT_342] = [__v_9];
-                    record.function_queries[342].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
-                  0u64 => {
-                    let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } else { aiur_fn_298(__args, record, io_buffer, __cu)? } };
-                    let __v_9: G = __r_arr[0];
-                    let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_10: G = __r_arr[0];
-                    match __v_10.as_canonical_u64() {
-                      1u64 => {
-                        let __v_11: G = G::from_u64(1);
-                        let __ret: [G; OUT_342] = [__v_11];
-                        record.function_queries[342].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                        return Ok(__ret);
-                      },
-                      0u64 => {
-                        let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[299].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_299] = unsafe { *(result.output.as_ptr() as *const [G; OUT_299]) }; __ret } else { aiur_fn_299(__args, record, io_buffer, __cu)? } };
-                        let __v_11: G = __r_arr[0];
-                        let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_12: G = __r_arr[0];
-                        match __v_12.as_canonical_u64() {
-                          1u64 => {
-                            let __v_13: G = G::from_u64(1);
-                            let __ret: [G; OUT_342] = [__v_13];
-                            record.function_queries[342].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                            return Ok(__ret);
-                          },
-                          0u64 => {
-                            let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } else { aiur_fn_297(__args, record, io_buffer, __cu)? } };
-                            let __v_13: G = __r_arr[0];
-                            let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_14: G = __r_arr[0];
-                            match __v_14.as_canonical_u64() {
-                              1u64 => {
-                                let __v_15: G = G::from_u64(1);
-                                let __ret: [G; OUT_342] = [__v_15];
-                                record.function_queries[342].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                return Ok(__ret);
-                              },
-                              0u64 => {
-                                let __v_15: G = G::from_u64(0);
-                                let __ret: [G; OUT_342] = [__v_15];
-                                record.function_queries[342].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                return Ok(__ret);
-                              },
-                              _ => {
-                                return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64()));
-                              },
-                            }
-                          },
-                          _ => {
-                            return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64()));
-                          },
-                        }
-                      },
-                      _ => {
-                        return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64()));
-                      },
-                    }
-                  },
-                  _ => {
-                    return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64()));
-                  },
-                }
-              },
-              _ => {
-                return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64()));
-              },
-            }
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
-          },
-        }
-      },
+    }
+  })
+}
+
+const INPUT_SIZE_252: usize = 40;
+const IN_252: usize = 40;
+const OUT_252: usize = 12;
+fn aiur_fn_252(
+  inp: [G; IN_252],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_252], 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];
+    match __v_0.as_canonical_u64() {
       _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+        let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_33, __v_36, __v_37, __v_38, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } else { aiur_fn_245(__args, record, io_buffer, __cu)? } };
+        let __v_40: G = __r_arr[0];
+        let __v_41: G = G::from_u64(6);
+        let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__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[15].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } else { aiur_fn_15(__args, record, io_buffer, __cu)? } };
+        let __v_42: G = __r_arr[0];
+        let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__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[15].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } else { aiur_fn_15(__args, record, io_buffer, __cu)? } };
+        let __v_43: G = __r_arr[0];
+        let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__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[15].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } else { aiur_fn_15(__args, record, io_buffer, __cu)? } };
+        let __v_44: G = __r_arr[0];
+        let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__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[15].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } else { aiur_fn_15(__args, record, io_buffer, __cu)? } };
+        let __v_45: G = __r_arr[0];
+        let __v_46: G = G::from_u64(0);
+        let __ret: [G; OUT_252] = [__v_41, __v_42, __v_40, __v_34, __v_35, __v_43, __v_44, __v_45, __v_0, __v_46, __v_46, __v_46];
+        record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_343: usize = 1;
-const IN_343: usize = 1;
-const OUT_343: usize = 1;
-fn aiur_fn_343(
-  inp: [G; IN_343],
+const INPUT_SIZE_253: usize = 6;
+const IN_253: usize = 6;
+const OUT_253: usize = 1;
+fn aiur_fn_253(
+  inp: [G; IN_253],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_343], ExecError> {
+) -> Result<[G; OUT_253], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[238].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_238] = unsafe { *(result.output.as_ptr() as *const [G; OUT_238]) }; __ret } else { aiur_fn_238(__args, record, io_buffer, __cu)? } };
-    let __v_1: G = __r_arr[0];
-    let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_2: G = __r_arr[0];
-    match __v_2.as_canonical_u64() {
+    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; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].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];
+    let __v_13: G = __loaded[7];
+    let __v_14: G = __loaded[8];
+    let __v_15: G = __loaded[9];
+    let __v_16: G = __loaded[10];
+    match __v_6.as_canonical_u64() {
       1u64 => {
-        let __v_3: G = G::from_u64(1);
-        let __ret: [G; OUT_343] = [__v_3];
-        record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __v_17: G = G::from_u64(1);
+        let __v_18: G = G::from_u64(1);
+        let __v_19: G = { let __values: [G; 5] = [__v_17, __v_18, __v_18, __v_18, __v_18]; 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_253] = [__v_19];
+        record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[240].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_240] = unsafe { *(result.output.as_ptr() as *const [G; OUT_240]) }; __ret } else { aiur_fn_240(__args, record, io_buffer, __cu)? } };
-        let __v_3: G = __r_arr[0];
-        let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_4: G = __r_arr[0];
-        match __v_4.as_canonical_u64() {
-          1u64 => {
-            let __v_5: G = G::from_u64(1);
-            let __ret: [G; OUT_343] = [__v_5];
-            record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          0u64 => {
-            let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } else { aiur_fn_241(__args, record, io_buffer, __cu)? } };
-            let __v_5: G = __r_arr[0];
-            let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_6: G = __r_arr[0];
-            match __v_6.as_canonical_u64() {
-              1u64 => {
-                let __v_7: G = G::from_u64(1);
-                let __ret: [G; OUT_343] = [__v_7];
-                record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              0u64 => {
-                let __v_7: G = G::from_u64(0);
-                let __ret: [G; OUT_343] = [__v_7];
-                record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              _ => {
-                return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64()));
-              },
-            }
-          },
+        match __v_7.as_canonical_u64() {
           _ => {
-            return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
+            let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_15, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } else { aiur_fn_245(__args, record, io_buffer, __cu)? } };
+            let __v_17: G = __r_arr[0];
+            let __v_18: G = G::from_u64(0);
+            let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__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[15].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } else { aiur_fn_15(__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_5 + __v_20);
+            let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_16, __v_1, __v_2, __v_3, __v_4, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[253].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_253] = unsafe { *(result.output.as_ptr() as *const [G; OUT_253]) }; __ret } else { aiur_fn_253(__args, record, io_buffer, __cu)? } };
+            let __v_22: G = __r_arr[0];
+            let __v_23: G = { let __values: [G; 5] = [__v_18, __v_5, __v_19, __v_17, __v_22]; 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_253] = [__v_23];
+            record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
           },
         }
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+        return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_344: usize = 1;
-const IN_344: usize = 1;
-const OUT_344: usize = 1;
-fn aiur_fn_344(
-  inp: [G; IN_344],
+const INPUT_SIZE_254: usize = 50;
+const IN_254: usize = 50;
+const OUT_254: usize = 12;
+fn aiur_fn_254(
+  inp: [G; IN_254],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_344], ExecError> {
+) -> Result<[G; OUT_254], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_262] = { let __args: [G; IN_262] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[262].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_262] = unsafe { *(result.output.as_ptr() as *const [G; OUT_262]) }; __ret } else { aiur_fn_262(__args, record, io_buffer, __cu)? } };
-    let __v_1: G = __r_arr[0];
-    let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_2: G = __r_arr[0];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
-        let __v_3: G = G::from_u64(1);
-        let __ret: [G; OUT_344] = [__v_3];
-        record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[263].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_263] = unsafe { *(result.output.as_ptr() as *const [G; OUT_263]) }; __ret } else { aiur_fn_263(__args, record, io_buffer, __cu)? } };
-        let __v_3: G = __r_arr[0];
-        let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_4: G = __r_arr[0];
-        match __v_4.as_canonical_u64() {
-          1u64 => {
-            let __v_5: G = G::from_u64(1);
-            let __ret: [G; OUT_344] = [__v_5];
-            record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          0u64 => {
-            let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[266].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_266] = unsafe { *(result.output.as_ptr() as *const [G; OUT_266]) }; __ret } else { aiur_fn_266(__args, record, io_buffer, __cu)? } };
-            let __v_5: G = __r_arr[0];
-            let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_6: G = __r_arr[0];
-            match __v_6.as_canonical_u64() {
-              1u64 => {
-                let __v_7: G = G::from_u64(1);
-                let __ret: [G; OUT_344] = [__v_7];
-                record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              0u64 => {
-                let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } else { aiur_fn_268(__args, record, io_buffer, __cu)? } };
-                let __v_7: G = __r_arr[0];
-                let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_8: G = __r_arr[0];
-                match __v_8.as_canonical_u64() {
-                  1u64 => {
-                    let __v_9: G = G::from_u64(1);
-                    let __ret: [G; OUT_344] = [__v_9];
-                    record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
-                  0u64 => {
-                    let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = unsafe { *(result.output.as_ptr() as *const [G; OUT_267]) }; __ret } else { aiur_fn_267(__args, record, io_buffer, __cu)? } };
-                    let __v_9: G = __r_arr[0];
-                    let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_10: G = __r_arr[0];
-                    match __v_10.as_canonical_u64() {
-                      1u64 => {
-                        let __v_11: G = G::from_u64(1);
-                        let __ret: [G; OUT_344] = [__v_11];
-                        record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                        return Ok(__ret);
-                      },
-                      0u64 => {
-                        let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[264].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_264] = unsafe { *(result.output.as_ptr() as *const [G; OUT_264]) }; __ret } else { aiur_fn_264(__args, record, io_buffer, __cu)? } };
-                        let __v_11: G = __r_arr[0];
-                        let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_12: G = __r_arr[0];
-                        match __v_12.as_canonical_u64() {
-                          1u64 => {
-                            let __v_13: G = G::from_u64(1);
-                            let __ret: [G; OUT_344] = [__v_13];
-                            record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                            return Ok(__ret);
-                          },
-                          0u64 => {
-                            let __v_13: G = G::from_u64(0);
-                            let __ret: [G; OUT_344] = [__v_13];
-                            record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                            return Ok(__ret);
-                          },
-                          _ => {
-                            return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64()));
-                          },
-                        }
-                      },
-                      _ => {
-                        return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64()));
-                      },
-                    }
-                  },
-                  _ => {
-                    return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64()));
-                  },
-                }
-              },
-              _ => {
-                return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64()));
-              },
-            }
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
-          },
-        }
-      },
+    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];
+    match __v_0.as_canonical_u64() {
       _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+        let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_42, __v_46, __v_47, __v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } else { aiur_fn_245(__args, record, io_buffer, __cu)? } };
+        let __v_50: G = __r_arr[0];
+        let __v_51: G = G::from_u64(0);
+        let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_43, __v_46, __v_47, __v_48, __v_49, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[253].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_253] = unsafe { *(result.output.as_ptr() as *const [G; OUT_253]) }; __ret } else { aiur_fn_253(__args, record, io_buffer, __cu)? } };
+        let __v_52: G = __r_arr[0];
+        let __v_53: G = G::from_u64(7);
+        let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } else { aiur_fn_15(__args, record, io_buffer, __cu)? } };
+        let __v_54: G = __r_arr[0];
+        let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } else { aiur_fn_15(__args, record, io_buffer, __cu)? } };
+        let __v_55: G = __r_arr[0];
+        let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } else { aiur_fn_15(__args, record, io_buffer, __cu)? } };
+        let __v_56: G = __r_arr[0];
+        let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } else { aiur_fn_15(__args, record, io_buffer, __cu)? } };
+        let __v_57: G = __r_arr[0];
+        let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } else { aiur_fn_15(__args, record, io_buffer, __cu)? } };
+        let __v_58: G = __r_arr[0];
+        let __ret: [G; OUT_254] = [__v_53, __v_54, __v_50, __v_55, __v_56, __v_57, __v_58, __v_52, __v_0, __v_1, __v_44, __v_45];
+        record.function_queries[254].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_345: usize = 1;
-const IN_345: usize = 1;
-const OUT_345: usize = 1;
-fn aiur_fn_345(
-  inp: [G; IN_345],
+const INPUT_SIZE_255: usize = 1;
+const IN_255: usize = 1;
+const OUT_255: usize = 48;
+fn aiur_fn_255(
+  inp: [G; IN_255],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_345], ExecError> {
+) -> Result<[G; OUT_255], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[247].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_247] = unsafe { *(result.output.as_ptr() as *const [G; OUT_247]) }; __ret } else { aiur_fn_247(__args, record, io_buffer, __cu)? } };
-    let __v_1: G = __r_arr[0];
-    let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_2: G = __r_arr[0];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
-        let __v_3: G = G::from_u64(1);
-        let __ret: [G; OUT_345] = [__v_3];
-        record.function_queries[345].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
+    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_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 = G::from_u64(2);
+    let __io_pair: (G, G) = { let __key: [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 __info = io_buffer.get_info(__v_33, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) };
+    let __v_34: G = __io_pair.0;
+    let __v_35: G = __io_pair.1;
+    let __v_36: G = G::from_u64(2);
+    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_36, __v_34, __v_35]; let __cu = true; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
+    let __v_37: G = __r_arr[0];
+    let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_37, __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[17].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } else { aiur_fn_17(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[105].get_mut(&__args[..]) { 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_38: G = __r_arr[0];
+    let __v_39: G = __r_arr[1];
+    let __v_40: G = __r_arr[2];
+    let __v_41: G = __r_arr[3];
+    let __v_42: G = __r_arr[4];
+    let __v_43: G = __r_arr[5];
+    let __v_44: G = __r_arr[6];
+    let __v_45: G = __r_arr[7];
+    let __v_46: G = __r_arr[8];
+    let __v_47: G = __r_arr[9];
+    let __v_48: G = __r_arr[10];
+    let __v_49: G = __r_arr[11];
+    let __v_50: G = __r_arr[12];
+    let __v_51: G = __r_arr[13];
+    let __v_52: G = __r_arr[14];
+    let __v_53: G = __r_arr[15];
+    let __v_54: G = __r_arr[16];
+    let __v_55: G = __r_arr[17];
+    let __v_56: G = __r_arr[18];
+    let __v_57: G = __r_arr[19];
+    let __v_58: G = __r_arr[20];
+    let __v_59: G = __r_arr[21];
+    let __v_60: G = __r_arr[22];
+    let __v_61: G = __r_arr[23];
+    let __v_62: G = __r_arr[24];
+    let __v_63: G = __r_arr[25];
+    let __v_64: G = __r_arr[26];
+    let __v_65: G = __r_arr[27];
+    let __v_66: G = __r_arr[28];
+    let __v_67: G = __r_arr[29];
+    let __v_68: G = __r_arr[30];
+    let __v_69: G = __r_arr[31];
+    let __v_70: G = __r_arr[32];
+    let __v_71: G = __r_arr[33];
+    let __v_72: G = __r_arr[34];
+    let __v_73: G = __r_arr[35];
+    let __v_74: G = __r_arr[36];
+    let __v_75: G = __r_arr[37];
+    let __v_76: G = __r_arr[38];
+    let __v_77: G = __r_arr[39];
+    let __v_78: G = __r_arr[40];
+    let __v_79: G = __r_arr[41];
+    let __v_80: G = __r_arr[42];
+    let __v_81: G = __r_arr[43];
+    let __v_82: G = __r_arr[44];
+    let __v_83: G = __r_arr[45];
+    let __v_84: G = __r_arr[46];
+    let __v_85: G = __r_arr[47];
+    let __v_86: G = __r_arr[48];
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_86.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).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_87: G = __loaded[0];
+    let __v_88: G = __loaded[1];
+    let __v_89: G = __loaded[2];
+    let __v_90: G = G::from_u64(1);
+    let __v_91: G = G::from_u64(1);
+    if (__v_87 != __v_90) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_87.as_canonical_u64(), rhs: __v_90.as_canonical_u64(), msg: Some("trailing bytes after constant on ch 2".to_string()) });
+    }
+    if (__v_88 != __v_91) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_88.as_canonical_u64(), rhs: __v_91.as_canonical_u64(), msg: Some("trailing bytes after constant on ch 2".to_string()) });
+    }
+    if (__v_89 != __v_91) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_89.as_canonical_u64(), rhs: __v_91.as_canonical_u64(), msg: Some("trailing bytes after constant on ch 2".to_string()) });
+    }
+    let __ret: [G; OUT_255] = [__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];
+    record.function_queries[255].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_256: usize = 1;
+const IN_256: usize = 1;
+const OUT_256: usize = 1;
+fn aiur_fn_256(
+  inp: [G; IN_256],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_256], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    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_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 = G::from_u64(3);
+    let __io_pair: (G, G) = { let __key: [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 __info = io_buffer.get_info(__v_33, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) };
+    let __v_34: G = __io_pair.0;
+    let __v_35: G = __io_pair.1;
+    let __v_36: G = G::from_u64(3);
+    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_36, __v_34, __v_35]; let __cu = true; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
+    let __v_37: 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_37.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).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_38: G = __loaded[0];
+    let __v_39: G = __loaded[1];
+    let __v_40: G = __loaded[2];
+    match __v_38.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[248].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_248] = unsafe { *(result.output.as_ptr() as *const [G; OUT_248]) }; __ret } else { aiur_fn_248(__args, record, io_buffer, __cu)? } };
-        let __v_3: G = __r_arr[0];
-        let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_4: G = __r_arr[0];
-        match __v_4.as_canonical_u64() {
-          1u64 => {
-            let __v_5: G = G::from_u64(1);
-            let __ret: [G; OUT_345] = [__v_5];
-            record.function_queries[345].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          0u64 => {
-            let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[246].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_246] = unsafe { *(result.output.as_ptr() as *const [G; OUT_246]) }; __ret } else { aiur_fn_246(__args, record, io_buffer, __cu)? } };
-            let __v_5: G = __r_arr[0];
-            let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_6: G = __r_arr[0];
-            match __v_6.as_canonical_u64() {
-              1u64 => {
-                let __v_7: G = G::from_u64(1);
-                let __ret: [G; OUT_345] = [__v_7];
-                record.function_queries[345].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              0u64 => {
-                let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[249].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_249] = unsafe { *(result.output.as_ptr() as *const [G; OUT_249]) }; __ret } else { aiur_fn_249(__args, record, io_buffer, __cu)? } };
-                let __v_7: G = __r_arr[0];
-                let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_8: G = __r_arr[0];
-                match __v_8.as_canonical_u64() {
-                  1u64 => {
-                    let __v_9: G = G::from_u64(1);
-                    let __ret: [G; OUT_345] = [__v_9];
-                    record.function_queries[345].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
-                  0u64 => {
-                    let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } else { aiur_fn_251(__args, record, io_buffer, __cu)? } };
-                    let __v_9: G = __r_arr[0];
-                    let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_10: G = __r_arr[0];
-                    match __v_10.as_canonical_u64() {
-                      1u64 => {
-                        let __v_11: G = G::from_u64(1);
-                        let __ret: [G; OUT_345] = [__v_11];
-                        record.function_queries[345].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                        return Ok(__ret);
-                      },
-                      0u64 => {
-                        let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[250].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_250] = unsafe { *(result.output.as_ptr() as *const [G; OUT_250]) }; __ret } else { aiur_fn_250(__args, record, io_buffer, __cu)? } };
-                        let __v_11: G = __r_arr[0];
-                        let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_12: G = __r_arr[0];
-                        match __v_12.as_canonical_u64() {
-                          1u64 => {
-                            let __v_13: G = G::from_u64(1);
-                            let __ret: [G; OUT_345] = [__v_13];
-                            record.function_queries[345].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                            return Ok(__ret);
-                          },
-                          0u64 => {
-                            let __v_13: G = G::from_u64(0);
-                            let __ret: [G; OUT_345] = [__v_13];
-                            record.function_queries[345].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                            return Ok(__ret);
-                          },
-                          _ => {
-                            return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64()));
-                          },
-                        }
-                      },
-                      _ => {
-                        return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64()));
-                      },
-                    }
-                  },
-                  _ => {
-                    return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64()));
-                  },
-                }
-              },
-              _ => {
-                return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64()));
-              },
-            }
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
-          },
-        }
+        let __ret: [G; OUT_256] = [__v_39];
+        record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+        return Err(ExecError::MatchNoCase(__v_38.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_346: usize = 5;
-const IN_346: usize = 5;
-const OUT_346: usize = 2;
-fn aiur_fn_346(
-  inp: [G; IN_346],
+const INPUT_SIZE_257: usize = 1;
+const IN_257: usize = 1;
+const OUT_257: usize = 1;
+fn aiur_fn_257(
+  inp: [G; IN_257],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_257], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    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_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 = G::from_u64(4);
+    let __io_pair: (G, G) = { let __key: [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 __info = io_buffer.get_info(__v_33, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) };
+    let __v_34: G = __io_pair.0;
+    let __v_35: G = __io_pair.1;
+    let __v_36: G = G::from_u64(4);
+    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_36, __v_34, __v_35]; let __cu = true; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
+    let __v_37: G = __r_arr[0];
+    let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_37, __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[17].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } else { aiur_fn_17(__args, record, io_buffer, __cu)? } };
+    let __ret: [G; OUT_257] = [__v_37];
+    record.function_queries[257].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_258: usize = 1;
+const IN_258: usize = 1;
+const OUT_258: usize = 1;
+fn aiur_fn_258(
+  inp: [G; IN_258],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_346], ExecError> {
+) -> Result<[G; OUT_258], 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_187] = { let __args: [G; IN_187] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { 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_5: G = __r_arr[0];
-    let __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[274].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_274] = unsafe { *(result.output.as_ptr() as *const [G; OUT_274]) }; __ret } else { aiur_fn_274(__args, record, io_buffer, __cu)? } };
-    let __v_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_7: G = __r_arr[0];
-    let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[273].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_273] = unsafe { *(result.output.as_ptr() as *const [G; OUT_273]) }; __ret } else { aiur_fn_273(__args, record, io_buffer, __cu)? } };
-    let __v_8: G = __r_arr[0];
-    let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_9: G = __r_arr[0];
-    match __v_9.as_canonical_u64() {
+    let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } else { aiur_fn_255(__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 __v_11: G = __r_arr[10];
+    let __v_12: G = __r_arr[11];
+    let __v_13: G = __r_arr[12];
+    let __v_14: G = __r_arr[13];
+    let __v_15: G = __r_arr[14];
+    let __v_16: G = __r_arr[15];
+    let __v_17: G = __r_arr[16];
+    let __v_18: G = __r_arr[17];
+    let __v_19: G = __r_arr[18];
+    let __v_20: G = __r_arr[19];
+    let __v_21: G = __r_arr[20];
+    let __v_22: G = __r_arr[21];
+    let __v_23: G = __r_arr[22];
+    let __v_24: G = __r_arr[23];
+    let __v_25: G = __r_arr[24];
+    let __v_26: G = __r_arr[25];
+    let __v_27: G = __r_arr[26];
+    let __v_28: G = __r_arr[27];
+    let __v_29: G = __r_arr[28];
+    let __v_30: G = __r_arr[29];
+    let __v_31: G = __r_arr[30];
+    let __v_32: G = __r_arr[31];
+    let __v_33: G = __r_arr[32];
+    let __v_34: G = __r_arr[33];
+    let __v_35: G = __r_arr[34];
+    let __v_36: G = __r_arr[35];
+    let __v_37: G = __r_arr[36];
+    let __v_38: G = __r_arr[37];
+    let __v_39: G = __r_arr[38];
+    let __v_40: G = __r_arr[39];
+    let __v_41: G = __r_arr[40];
+    let __v_42: G = __r_arr[41];
+    let __v_43: G = __r_arr[42];
+    let __v_44: G = __r_arr[43];
+    let __v_45: G = __r_arr[44];
+    let __v_46: G = __r_arr[45];
+    let __v_47: G = __r_arr[46];
+    let __v_48: G = __r_arr[47];
+    match __v_1.as_canonical_u64() {
+      _ => {
+        match __v_1.as_canonical_u64() {
+          0u64 => {
+            let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[256].get_mut(&__args[..]) { let __ret: [G; OUT_256] = unsafe { *(result.output.as_ptr() as *const [G; OUT_256]) }; __ret } else { aiur_fn_256(__args, record, io_buffer, __cu)? } };
+            let __v_49: G = __r_arr[0];
+            let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_2.as_canonical_u64() {
+  _ => {
+    match __v_3.as_canonical_u64() {
       1u64 => {
-        let __v_10: G = G::from_u64(1);
-        let __v_11: G = { let __a_val = __v_5.as_canonical_u64(); let __b_val = __v_10.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_11.as_canonical_u64() {
-          1u64 => {
-            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 = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; 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_346] = [__v_12, __v_16];
-            record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __v_50: G = G::from_u64(1);
+        let __v_51: G = G::from_u64(1);
+        let __v_52: G = { let __values: [G; 3] = [__v_50, __v_51, __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 } };
+        break '__mc_0 [__v_52];
+      },
+      _ => {
+        let __v_50: G = G::from_u64(0);
+        let __v_51: G = G::from_u64(1);
+        let __v_52: G = G::from_u64(1);
+        let __v_53: G = { let __values: [G; 3] = [__v_51, __v_52, __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_50, __v_0, __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 } };
+        break '__mc_0 [__v_54];
+      },
+    }
+  },
+}
+ };
+            let __v_50: G = __mc_out___mc_0[0];
+            let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__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_46, __v_47, __v_50, __v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[246].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_246] = unsafe { *(result.output.as_ptr() as *const [G; OUT_246]) }; __ret } else { aiur_fn_246(__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 = { let __values: [G; 12] = [__v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_258] = [__v_63];
+            record.function_queries[258].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
-          0u64 => {
-            let __v_12: G = G::from_u64(0);
-            let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-            let __v_13: G = __r_arr[0];
-            let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_13, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } };
-            let __v_14: G = __r_arr[0];
-            let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_14, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } else { aiur_fn_336(__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() {
-              1u64 => {
-                let __v_17: G = G::from_u64(1);
-                let __r_arr: [G; OUT_796] = { let __args: [G; IN_796] = [__v_1, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[796].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_796] = unsafe { *(result.output.as_ptr() as *const [G; OUT_796]) }; __ret } else { aiur_fn_796(__args, record, io_buffer, __cu)? } };
-                let __v_18: G = __r_arr[0];
-                let __v_19: G = G::from_u64(1);
-                let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[304].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_304] = unsafe { *(result.output.as_ptr() as *const [G; OUT_304]) }; __ret } else { aiur_fn_304(__args, record, io_buffer, __cu)? } };
-                let __v_20: G = __r_arr[0];
-                let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } else { aiur_fn_338(__args, record, io_buffer, __cu)? } };
-                let __v_21: G = __r_arr[0];
-                let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_21, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[427].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_427] = unsafe { *(result.output.as_ptr() as *const [G; OUT_427]) }; __ret } else { aiur_fn_427(__args, record, io_buffer, __cu)? } };
-                let __v_22: G = __r_arr[0];
-                let __ret: [G; OUT_346] = [__v_19, __v_22];
-                record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
+          2u64 => {
+            let __v_49: G = G::from_u64(1);
+            let __v_50: G = G::from_u64(1);
+            let __v_51: G = { let __values: [G; 3] = [__v_49, __v_50, __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 __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_46, __v_47, __v_51, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[247].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_247] = unsafe { *(result.output.as_ptr() as *const [G; OUT_247]) }; __ret } else { aiur_fn_247(__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 = { let __values: [G; 12] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_258] = [__v_64];
+            record.function_queries[258].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          3u64 => {
+            let __v_49: G = G::from_u64(1);
+            let __v_50: G = G::from_u64(1);
+            let __v_51: G = { let __values: [G; 3] = [__v_49, __v_50, __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 __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_46, __v_47, __v_51, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[248].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_248] = unsafe { *(result.output.as_ptr() as *const [G; OUT_248]) }; __ret } else { aiur_fn_248(__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 = { let __values: [G; 12] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_258] = [__v_64];
+            record.function_queries[258].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          7u64 => {
+            match __v_2.as_canonical_u64() {
               _ => {
-                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 = { let __values: [G; 4] = [__v_18, __v_19, __v_20, __v_20]; 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_346] = [__v_17, __v_21];
-                record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __r_arr: [G; OUT_259] = { let __args: [G; IN_259] = [__v_0, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[259].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_259] = unsafe { *(result.output.as_ptr() as *const [G; OUT_259]) }; __ret } else { aiur_fn_259(__args, record, io_buffer, __cu)? } };
+                let __v_49: G = __r_arr[0];
+                let __ret: [G; OUT_258] = [__v_49];
+                record.function_queries[258].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64()));
-          },
-        }
-      },
-      0u64 => {
-        match __v_7.as_canonical_u64() {
-          1u64 => {
-            let __v_10: G = G::from_u64(1);
-            let __v_11: G = { let __a_val = __v_5.as_canonical_u64(); let __b_val = __v_10.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_11.as_canonical_u64() {
-              1u64 => {
-                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 = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; 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_346] = [__v_12, __v_16];
-                record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              0u64 => {
-                let __v_12: G = G::from_u64(0);
-                let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-                let __v_13: G = __r_arr[0];
-                let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_13, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } };
-                let __v_14: G = __r_arr[0];
-                let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_14, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } else { aiur_fn_336(__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() {
-                  1u64 => {
-                    let __v_17: G = G::from_u64(1);
-                    let __r_arr: [G; OUT_796] = { let __args: [G; IN_796] = [__v_1, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[796].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_796] = unsafe { *(result.output.as_ptr() as *const [G; OUT_796]) }; __ret } else { aiur_fn_796(__args, record, io_buffer, __cu)? } };
-                    let __v_18: G = __r_arr[0];
-                    let __v_19: G = G::from_u64(1);
-                    let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } };
-                    let __v_20: G = __r_arr[0];
-                    let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } };
-                    let __v_21: G = __r_arr[0];
-                    let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } else { aiur_fn_338(__args, record, io_buffer, __cu)? } };
-                    let __v_22: G = __r_arr[0];
-                    let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_22, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[427].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_427] = unsafe { *(result.output.as_ptr() as *const [G; OUT_427]) }; __ret } else { aiur_fn_427(__args, record, io_buffer, __cu)? } };
-                    let __v_23: G = __r_arr[0];
-                    let __ret: [G; OUT_346] = [__v_19, __v_23];
-                    record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
-                  _ => {
-                    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 = { let __values: [G; 4] = [__v_18, __v_19, __v_20, __v_20]; 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_346] = [__v_17, __v_21];
-                    record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
-                }
-              },
+          6u64 => {
+            match __v_2.as_canonical_u64() {
               _ => {
-                return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64()));
+                let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } else { aiur_fn_15(__args, record, io_buffer, __cu)? } };
+                let __v_49: G = __r_arr[0];
+                let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_10, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[260].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_260] = unsafe { *(result.output.as_ptr() as *const [G; OUT_260]) }; __ret } else { aiur_fn_260(__args, record, io_buffer, __cu)? } };
+                let __v_50: G = __r_arr[0];
+                let __ret: [G; OUT_258] = [__v_50];
+                record.function_queries[258].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
               },
             }
           },
-          0u64 => {
-            let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_0, __v_1, __v_5, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[347].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_347] = unsafe { *(result.output.as_ptr() as *const [G; OUT_347]) }; __ret } else { aiur_fn_347(__args, record, io_buffer, __cu)? } };
-            let __v_10: G = __r_arr[0];
-            let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_346] = [__v_10, __v_11];
-            record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64()));
-          },
-        }
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_347: usize = 6;
-const IN_347: usize = 6;
-const OUT_347: usize = 2;
-fn aiur_fn_347(
-  inp: [G; IN_347],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_347], 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(2);
-    let __v_7: G = { let __a_val = __v_2.as_canonical_u64(); let __b_val = __v_6.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_7.as_canonical_u64() {
-      1u64 => {
-        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 = { let __values: [G; 4] = [__v_9, __v_10, __v_11, __v_11]; 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_347] = [__v_8, __v_12];
-        record.function_queries[347].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __v_8: G = G::from_u64(0);
-        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_1, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-        let __v_9: G = __r_arr[0];
-        let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_9, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } };
-        let __v_10: G = __r_arr[0];
-        let __v_11: G = G::from_u64(1);
-        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-        let __v_12: G = __r_arr[0];
-        let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_12, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } };
-        let __v_13: G = __r_arr[0];
-        let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_10, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } else { aiur_fn_336(__args, record, io_buffer, __cu)? } };
-        let __v_14: G = __r_arr[0];
-        let __v_15: G = __r_arr[1];
-        let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_13, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } else { aiur_fn_336(__args, record, io_buffer, __cu)? } };
-        let __v_16: G = __r_arr[0];
-        let __v_17: G = __r_arr[1];
-        match __v_14.as_canonical_u64() {
-          1u64 => {
-            match __v_16.as_canonical_u64() {
-              1u64 => {
-                let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_0, __v_15, __v_17, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[350].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_350] = unsafe { *(result.output.as_ptr() as *const [G; OUT_350]) }; __ret } else { aiur_fn_350(__args, record, io_buffer, __cu)? } };
-                let __v_18: G = __r_arr[0];
-                let __v_19: G = __r_arr[1];
-                match __v_18.as_canonical_u64() {
-                  1u64 => {
-                    let __v_20: G = G::from_u64(2);
-                    let __r_arr: [G; OUT_796] = { let __args: [G; IN_796] = [__v_1, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[796].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_796] = unsafe { *(result.output.as_ptr() as *const [G; OUT_796]) }; __ret } else { aiur_fn_796(__args, record, io_buffer, __cu)? } };
-                    let __v_21: G = __r_arr[0];
-                    let __v_22: G = G::from_u64(1);
-                    let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_19, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[427].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_427] = unsafe { *(result.output.as_ptr() as *const [G; OUT_427]) }; __ret } else { aiur_fn_427(__args, record, io_buffer, __cu)? } };
-                    let __v_23: G = __r_arr[0];
-                    let __ret: [G; OUT_347] = [__v_22, __v_23];
-                    record.function_queries[347].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
-                  0u64 => {
-                    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 __v_24: G = { let __values: [G; 4] = [__v_21, __v_22, __v_23, __v_23]; 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_347] = [__v_20, __v_24];
-                    record.function_queries[347].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
-                  _ => {
-                    return Err(ExecError::MatchNoCase(__v_18.as_canonical_u64()));
-                  },
-                }
-              },
+          4u64 => {
+            match __v_2.as_canonical_u64() {
               _ => {
-                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 = { let __values: [G; 4] = [__v_19, __v_20, __v_21, __v_21]; 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_347] = [__v_18, __v_22];
-                record.function_queries[347].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } else { aiur_fn_15(__args, record, io_buffer, __cu)? } };
+                let __v_49: G = __r_arr[0];
+                let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } else { aiur_fn_15(__args, record, io_buffer, __cu)? } };
+                let __v_50: G = __r_arr[0];
+                let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_18, __v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[261].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_261] = unsafe { *(result.output.as_ptr() as *const [G; OUT_261]) }; __ret } else { aiur_fn_261(__args, record, io_buffer, __cu)? } };
+                let __v_51: G = __r_arr[0];
+                let __ret: [G; OUT_258] = [__v_51];
+                record.function_queries[258].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
-          _ => {
-            match __v_16.as_canonical_u64() {
-              1u64 => {
-                let __r_arr: [G; OUT_348] = { let __args: [G; IN_348] = [__v_0, __v_10, __v_17, __v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[348].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_348] = unsafe { *(result.output.as_ptr() as *const [G; OUT_348]) }; __ret } else { aiur_fn_348(__args, record, io_buffer, __cu)? } };
-                let __v_18: G = __r_arr[0];
-                let __v_19: G = __r_arr[1];
-                let __ret: [G; OUT_347] = [__v_18, __v_19];
-                record.function_queries[347].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
+          5u64 => {
+            match __v_2.as_canonical_u64() {
               _ => {
-                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 = { let __values: [G; 4] = [__v_19, __v_20, __v_21, __v_21]; 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_347] = [__v_18, __v_22];
-                record.function_queries[347].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } else { aiur_fn_15(__args, record, io_buffer, __cu)? } };
+                let __v_49: G = __r_arr[0];
+                let __r_arr: [G; OUT_262] = { let __args: [G; IN_262] = [__v_10, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[262].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_262] = unsafe { *(result.output.as_ptr() as *const [G; OUT_262]) }; __ret } else { aiur_fn_262(__args, record, io_buffer, __cu)? } };
+                let __v_50: G = __r_arr[0];
+                let __ret: [G; OUT_258] = [__v_50];
+                record.function_queries[258].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
+          8u64 => {
+            let __v_49: G = G::from_u64(0);
+            let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_0, __v_2, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[263].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_263] = unsafe { *(result.output.as_ptr() as *const [G; OUT_263]) }; __ret } else { aiur_fn_263(__args, record, io_buffer, __cu)? } };
+            let __v_50: G = __r_arr[0];
+            let __ret: [G; OUT_258] = [__v_50];
+            record.function_queries[258].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          1u64 => {
+            let __v_49: G = G::from_u64(0);
+            let __v_50: G = G::from_u64(1);
+            let __v_51: G = G::from_u64(1);
+            let __v_52: G = { let __values: [G; 3] = [__v_50, __v_51, __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_49, __v_0, __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 = G::from_u64(0);
+            let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__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_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_0, __v_54, __v_46, __v_47, __v_53, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } else { aiur_fn_254(__args, record, io_buffer, __cu)? } };
+            let __v_55: G = __r_arr[0];
+            let __v_56: G = __r_arr[1];
+            let __v_57: G = __r_arr[2];
+            let __v_58: G = __r_arr[3];
+            let __v_59: G = __r_arr[4];
+            let __v_60: G = __r_arr[5];
+            let __v_61: G = __r_arr[6];
+            let __v_62: G = __r_arr[7];
+            let __v_63: G = __r_arr[8];
+            let __v_64: G = __r_arr[9];
+            let __v_65: G = __r_arr[10];
+            let __v_66: G = __r_arr[11];
+            let __v_67: G = { let __values: [G; 12] = [__v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_258] = [__v_67];
+            record.function_queries[258].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+          },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64()));
-      },
     }
   })
 }
 
-const INPUT_SIZE_348: usize = 5;
-const IN_348: usize = 5;
-const OUT_348: usize = 2;
-fn aiur_fn_348(
-  inp: [G; IN_348],
+const INPUT_SIZE_259: usize = 10;
+const IN_259: usize = 10;
+const OUT_259: usize = 1;
+fn aiur_fn_259(
+  inp: [G; IN_259],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_348], ExecError> {
+) -> Result<[G; OUT_259], 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_275] = { let __args: [G; IN_275] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[275].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_275] = unsafe { *(result.output.as_ptr() as *const [G; OUT_275]) }; __ret } else { aiur_fn_275(__args, record, io_buffer, __cu)? } };
-    let __v_5: G = __r_arr[0];
-    let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[281].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_281] = unsafe { *(result.output.as_ptr() as *const [G; OUT_281]) }; __ret } else { aiur_fn_281(__args, record, io_buffer, __cu)? } };
-    let __v_7: G = __r_arr[0];
-    let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_8: G = __r_arr[0];
-    let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[280].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_280] = unsafe { *(result.output.as_ptr() as *const [G; OUT_280]) }; __ret } else { aiur_fn_280(__args, record, io_buffer, __cu)? } };
-    let __v_9: G = __r_arr[0];
-    let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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 = 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 __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } else { aiur_fn_255(__args, record, io_buffer, __cu)? } };
     let __v_10: G = __r_arr[0];
-    let __v_11: G = (__v_8 + __v_10);
-    let __v_12: G = G::from_u64(1);
-    let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } else { aiur_fn_320(__args, record, io_buffer, __cu)? } };
-    let __v_13: G = __r_arr[0];
-    let __v_14: G = (__v_12 - __v_13);
-    let __v_15: G = G::from_u64(1);
-    let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } };
-    let __v_16: G = __r_arr[0];
-    let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } else { aiur_fn_320(__args, record, io_buffer, __cu)? } };
-    let __v_17: G = __r_arr[0];
-    let __v_18: G = (__v_15 - __v_17);
-    let __v_19: G = (__v_14 * __v_18);
-    let __v_20: G = (__v_11 * __v_19);
-    let __v_21: G = (__v_6 + __v_20);
-    match __v_21.as_canonical_u64() {
-      0u64 => {
-        let __v_22: G = G::from_u64(0);
-        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 __v_26: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_25]; 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_348] = [__v_22, __v_26];
-        record.function_queries[348].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
+    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 = __r_arr[9];
+    let __v_20: G = __r_arr[10];
+    let __v_21: G = __r_arr[11];
+    let __v_22: G = __r_arr[12];
+    let __v_23: G = __r_arr[13];
+    let __v_24: G = __r_arr[14];
+    let __v_25: G = __r_arr[15];
+    let __v_26: G = __r_arr[16];
+    let __v_27: G = __r_arr[17];
+    let __v_28: G = __r_arr[18];
+    let __v_29: G = __r_arr[19];
+    let __v_30: G = __r_arr[20];
+    let __v_31: G = __r_arr[21];
+    let __v_32: G = __r_arr[22];
+    let __v_33: G = __r_arr[23];
+    let __v_34: G = __r_arr[24];
+    let __v_35: G = __r_arr[25];
+    let __v_36: G = __r_arr[26];
+    let __v_37: G = __r_arr[27];
+    let __v_38: G = __r_arr[28];
+    let __v_39: G = __r_arr[29];
+    let __v_40: G = __r_arr[30];
+    let __v_41: G = __r_arr[31];
+    let __v_42: G = __r_arr[32];
+    let __v_43: G = __r_arr[33];
+    let __v_44: G = __r_arr[34];
+    let __v_45: G = __r_arr[35];
+    let __v_46: G = __r_arr[36];
+    let __v_47: G = __r_arr[37];
+    let __v_48: G = __r_arr[38];
+    let __v_49: G = __r_arr[39];
+    let __v_50: G = __r_arr[40];
+    let __v_51: G = __r_arr[41];
+    let __v_52: G = __r_arr[42];
+    let __v_53: G = __r_arr[43];
+    let __v_54: G = __r_arr[44];
+    let __v_55: G = __r_arr[45];
+    let __v_56: G = __r_arr[46];
+    let __v_57: G = __r_arr[47];
+    match __v_10.as_canonical_u64() {
       _ => {
-        let __v_22: G = G::from_u64(2);
-        let __r_arr: [G; OUT_796] = { let __args: [G; IN_796] = [__v_3, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[796].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_796] = unsafe { *(result.output.as_ptr() as *const [G; OUT_796]) }; __ret } else { aiur_fn_796(__args, record, io_buffer, __cu)? } };
-        let __v_23: G = __r_arr[0];
-        match __v_6.as_canonical_u64() {
-          1u64 => {
-            let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_1, __v_2, __v_23, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = unsafe { *(result.output.as_ptr() as *const [G; OUT_339]) }; __ret } else { aiur_fn_339(__args, record, io_buffer, __cu)? } };
-            let __v_24: G = __r_arr[0];
-            let __v_25: G = __r_arr[1];
-            match __v_24.as_canonical_u64() {
-              1u64 => {
-                let __v_26: G = G::from_u64(2);
-                let __ret: [G; OUT_348] = [__v_26, __v_25];
-                record.function_queries[348].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              0u64 => {
-                let __v_26: G = G::from_u64(0);
-                let __v_27: G = G::from_u64(0);
-                let __v_28: G = G::from_u64(0);
-                let __v_29: G = G::from_u64(0);
-                let __v_30: G = { let __values: [G; 4] = [__v_27, __v_28, __v_29, __v_29]; 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_348] = [__v_26, __v_30];
-                record.function_queries[348].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              _ => {
-                return Err(ExecError::MatchNoCase(__v_24.as_canonical_u64()));
-              },
-            }
-          },
-          0u64 => {
-            let __r_arr: [G; OUT_349] = { let __args: [G; IN_349] = [__v_0, __v_1, __v_2, __v_23, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[349].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_349] = unsafe { *(result.output.as_ptr() as *const [G; OUT_349]) }; __ret } else { aiur_fn_349(__args, record, io_buffer, __cu)? } };
-            let __v_24: G = __r_arr[0];
-            let __v_25: G = __r_arr[1];
-            match __v_24.as_canonical_u64() {
-              1u64 => {
-                let __v_26: G = G::from_u64(2);
-                let __ret: [G; OUT_348] = [__v_26, __v_25];
-                record.function_queries[348].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
+        match __v_10.as_canonical_u64() {
+          8u64 => {
+            let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_11, __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[715].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_715] = unsafe { *(result.output.as_ptr() as *const [G; OUT_715]) }; __ret } else { aiur_fn_715(__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];
+            let __v_61: G = __r_arr[3];
+            let __v_62: G = __r_arr[4];
+            let __v_63: G = __r_arr[5];
+            let __v_64: G = __r_arr[6];
+            let __v_65: G = __r_arr[7];
+            let __v_66: G = __r_arr[8];
+            let __v_67: G = __r_arr[9];
+            let __v_68: G = __r_arr[10];
+            let __v_69: G = __r_arr[11];
+            let __v_70: G = __r_arr[12];
+            let __v_71: G = __r_arr[13];
+            let __v_72: G = __r_arr[14];
+            let __v_73: G = __r_arr[15];
+            let __v_74: G = __r_arr[16];
+            let __v_75: G = __r_arr[17];
+            let __v_76: G = __r_arr[18];
+            let __v_77: G = __r_arr[19];
+            let __v_78: G = __r_arr[20];
+            let __v_79: G = __r_arr[21];
+            let __v_80: G = __r_arr[22];
+            let __v_81: G = __r_arr[23];
+            let __v_82: G = __r_arr[24];
+            let __v_83: G = __r_arr[25];
+            let __v_84: G = __r_arr[26];
+            let __v_85: G = __r_arr[27];
+            let __v_86: G = __r_arr[28];
+            let __v_87: G = __r_arr[29];
+            let __v_88: G = __r_arr[30];
+            let __v_89: G = __r_arr[31];
+            let __v_90: G = __r_arr[32];
+            let __v_91: G = __r_arr[33];
+            let __v_92: G = __r_arr[34];
+            let __v_93: G = __r_arr[35];
+            let __v_94: G = __r_arr[36];
+            let __v_95: G = __r_arr[37];
+            let __v_96: G = __r_arr[38];
+            let __v_97: G = __r_arr[39];
+            let __v_98: G = __r_arr[40];
+            let __v_99: G = __r_arr[41];
+            let __v_100: G = __r_arr[42];
+            let __v_101: G = __r_arr[43];
+            let __v_102: G = __r_arr[44];
+            match __v_58.as_canonical_u64() {
               0u64 => {
-                let __v_26: G = G::from_u64(0);
-                let __v_27: G = G::from_u64(0);
-                let __v_28: G = G::from_u64(0);
-                let __v_29: G = G::from_u64(0);
-                let __v_30: G = { let __values: [G; 4] = [__v_27, __v_28, __v_29, __v_29]; 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_348] = [__v_26, __v_30];
-                record.function_queries[348].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[256].get_mut(&__args[..]) { let __ret: [G; OUT_256] = unsafe { *(result.output.as_ptr() as *const [G; OUT_256]) }; __ret } else { aiur_fn_256(__args, record, io_buffer, __cu)? } };
+                let __v_103: G = __r_arr[0];
+                let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_11, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = unsafe { *(result.output.as_ptr() as *const [G; OUT_267]) }; __ret } else { aiur_fn_267(__args, record, io_buffer, __cu)? } };
+                let __v_104: G = __r_arr[0];
+                let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__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_55, __v_56, __v_104, __v_57, __v_103]; let __cu = unconstrained; if let Some(result) = record.function_queries[246].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_246] = unsafe { *(result.output.as_ptr() as *const [G; OUT_246]) }; __ret } else { aiur_fn_246(__args, record, io_buffer, __cu)? } };
+                let __v_105: G = __r_arr[0];
+                let __v_106: G = __r_arr[1];
+                let __v_107: G = __r_arr[2];
+                let __v_108: G = __r_arr[3];
+                let __v_109: G = __r_arr[4];
+                let __v_110: G = __r_arr[5];
+                let __v_111: G = __r_arr[6];
+                let __v_112: G = __r_arr[7];
+                let __v_113: G = __r_arr[8];
+                let __v_114: G = __r_arr[9];
+                let __v_115: G = __r_arr[10];
+                let __v_116: G = __r_arr[11];
+                let __v_117: G = { let __values: [G; 12] = [__v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_259] = [__v_117];
+                record.function_queries[259].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                return Err(ExecError::MatchNoCase(__v_24.as_canonical_u64()));
+                return Err(ExecError::MatchNoCase(__v_58.as_canonical_u64()));
               },
             }
           },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64()));
+            return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64()));
           },
         }
       },
@@ -31731,4199 +24422,3653 @@ fn aiur_fn_348(
   })
 }
 
-const INPUT_SIZE_349: usize = 5;
-const IN_349: usize = 5;
-const OUT_349: usize = 2;
-fn aiur_fn_349(
-  inp: [G; IN_349],
+const INPUT_SIZE_260: usize = 2;
+const IN_260: usize = 2;
+const OUT_260: usize = 1;
+fn aiur_fn_260(
+  inp: [G; IN_260],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_349], 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 __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_0, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } else { aiur_fn_334(__args, record, io_buffer, __cu)? } };
-    let __v_6: G = __r_arr[0];
-    let __v_7: G = __r_arr[1];
-    match __v_6.as_canonical_u64() {
-      0u64 => {
-        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 = { let __values: [G; 4] = [__v_9, __v_10, __v_11, __v_11]; 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_349] = [__v_8, __v_12];
-        record.function_queries[349].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      1u64 => {
-        let __v_8: G = G::from_u64(2);
-        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 __v_12: G = G::from_u64(0);
-        let __v_13: G = { let __values: [G; 4] = [__v_8, __v_7, __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 __v_14: G = G::from_u64(3);
-        let __v_15: G = G::from_u64(3);
-        let __v_16: G = G::from_u64(0);
-        let __v_17: G = { let __values: [G; 4] = [__v_15, __v_13, __v_1, __v_16]; 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_338] = { let __args: [G; IN_338] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } else { aiur_fn_338(__args, record, io_buffer, __cu)? } };
-        let __v_18: G = __r_arr[0];
-        let __v_19: G = G::from_u64(0);
-        let __v_20: G = { let __values: [G; 4] = [__v_14, __v_17, __v_18, __v_19]; 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_21: G = G::from_u64(1);
-        let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_20, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[427].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_427] = unsafe { *(result.output.as_ptr() as *const [G; OUT_427]) }; __ret } else { aiur_fn_427(__args, record, io_buffer, __cu)? } };
-        let __v_22: G = __r_arr[0];
-        let __ret: [G; OUT_349] = [__v_21, __v_22];
-        record.function_queries[349].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
+) -> Result<[G; OUT_260], 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_255] = { let __args: [G; IN_255] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } else { aiur_fn_255(__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 = __r_arr[10];
+    let __v_13: G = __r_arr[11];
+    let __v_14: G = __r_arr[12];
+    let __v_15: G = __r_arr[13];
+    let __v_16: G = __r_arr[14];
+    let __v_17: G = __r_arr[15];
+    let __v_18: G = __r_arr[16];
+    let __v_19: G = __r_arr[17];
+    let __v_20: G = __r_arr[18];
+    let __v_21: G = __r_arr[19];
+    let __v_22: G = __r_arr[20];
+    let __v_23: G = __r_arr[21];
+    let __v_24: G = __r_arr[22];
+    let __v_25: G = __r_arr[23];
+    let __v_26: G = __r_arr[24];
+    let __v_27: G = __r_arr[25];
+    let __v_28: G = __r_arr[26];
+    let __v_29: G = __r_arr[27];
+    let __v_30: G = __r_arr[28];
+    let __v_31: G = __r_arr[29];
+    let __v_32: G = __r_arr[30];
+    let __v_33: G = __r_arr[31];
+    let __v_34: G = __r_arr[32];
+    let __v_35: G = __r_arr[33];
+    let __v_36: G = __r_arr[34];
+    let __v_37: G = __r_arr[35];
+    let __v_38: G = __r_arr[36];
+    let __v_39: G = __r_arr[37];
+    let __v_40: G = __r_arr[38];
+    let __v_41: G = __r_arr[39];
+    let __v_42: G = __r_arr[40];
+    let __v_43: G = __r_arr[41];
+    let __v_44: G = __r_arr[42];
+    let __v_45: G = __r_arr[43];
+    let __v_46: G = __r_arr[44];
+    let __v_47: G = __r_arr[45];
+    let __v_48: G = __r_arr[46];
+    let __v_49: G = __r_arr[47];
+    match __v_2.as_canonical_u64() {
       _ => {
-        return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64()));
+        match __v_2.as_canonical_u64() {
+          8u64 => {
+            let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[264].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_264] = unsafe { *(result.output.as_ptr() as *const [G; OUT_264]) }; __ret } else { aiur_fn_264(__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 __v_61: G = __r_arr[11];
+            let __v_62: G = __r_arr[12];
+            let __v_63: G = __r_arr[13];
+            let __v_64: G = __r_arr[14];
+            let __v_65: G = __r_arr[15];
+            let __v_66: G = __r_arr[16];
+            let __v_67: G = __r_arr[17];
+            let __v_68: G = __r_arr[18];
+            let __v_69: G = __r_arr[19];
+            let __v_70: G = __r_arr[20];
+            let __v_71: G = __r_arr[21];
+            let __v_72: G = __r_arr[22];
+            let __v_73: G = __r_arr[23];
+            let __v_74: G = __r_arr[24];
+            let __v_75: G = __r_arr[25];
+            let __v_76: G = __r_arr[26];
+            let __v_77: G = __r_arr[27];
+            let __v_78: G = __r_arr[28];
+            let __v_79: G = __r_arr[29];
+            let __v_80: G = __r_arr[30];
+            let __v_81: G = __r_arr[31];
+            let __v_82: G = __r_arr[32];
+            let __v_83: G = __r_arr[33];
+            let __v_84: G = __r_arr[34];
+            let __v_85: G = __r_arr[35];
+            let __v_86: G = __r_arr[36];
+            let __v_87: G = __r_arr[37];
+            let __v_88: G = __r_arr[38];
+            let __v_89: G = __r_arr[39];
+            let __v_90: G = __r_arr[40];
+            let __v_91: G = __r_arr[41];
+            let __v_92: G = __r_arr[42];
+            let __v_93: G = __r_arr[43];
+            let __v_94: G = __r_arr[44];
+            match __v_50.as_canonical_u64() {
+              1u64 => {
+                let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_3, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = unsafe { *(result.output.as_ptr() as *const [G; OUT_267]) }; __ret } else { aiur_fn_267(__args, record, io_buffer, __cu)? } };
+                let __v_95: G = __r_arr[0];
+                let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__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_0, __v_1, __v_47, __v_48, __v_95, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } else { aiur_fn_251(__args, record, io_buffer, __cu)? } };
+                let __v_96: G = __r_arr[0];
+                let __v_97: G = __r_arr[1];
+                let __v_98: G = __r_arr[2];
+                let __v_99: G = __r_arr[3];
+                let __v_100: G = __r_arr[4];
+                let __v_101: G = __r_arr[5];
+                let __v_102: G = __r_arr[6];
+                let __v_103: G = __r_arr[7];
+                let __v_104: G = __r_arr[8];
+                let __v_105: G = __r_arr[9];
+                let __v_106: G = __r_arr[10];
+                let __v_107: G = __r_arr[11];
+                let __v_108: G = { let __values: [G; 12] = [__v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_260] = [__v_108];
+                record.function_queries[260].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                return Err(ExecError::MatchNoCase(__v_50.as_canonical_u64()));
+              },
+            }
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+          },
+        }
       },
     }
   })
 }
 
-const INPUT_SIZE_350: usize = 4;
-const IN_350: usize = 4;
-const OUT_350: usize = 2;
-fn aiur_fn_350(
-  inp: [G; IN_350],
+const INPUT_SIZE_261: usize = 3;
+const IN_261: usize = 3;
+const OUT_261: usize = 1;
+fn aiur_fn_261(
+  inp: [G; IN_261],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_350], ExecError> {
+) -> Result<[G; OUT_261], 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_275] = { let __args: [G; IN_275] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[275].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_275] = unsafe { *(result.output.as_ptr() as *const [G; OUT_275]) }; __ret } else { aiur_fn_275(__args, record, io_buffer, __cu)? } };
-    let __v_4: G = __r_arr[0];
-    let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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];
-    match __v_5.as_canonical_u64() {
-      1u64 => {
-        let __v_6: G = G::from_u64(1);
-        let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } else { aiur_fn_306(__args, record, io_buffer, __cu)? } };
-        let __v_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } };
-        let __v_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } else { aiur_fn_338(__args, record, io_buffer, __cu)? } };
-        let __v_9: G = __r_arr[0];
-        let __ret: [G; OUT_350] = [__v_6, __v_9];
-        record.function_queries[350].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __r_arr: [G; OUT_276] = { let __args: [G; IN_276] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[276].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_276] = unsafe { *(result.output.as_ptr() as *const [G; OUT_276]) }; __ret } else { aiur_fn_276(__args, record, io_buffer, __cu)? } };
-        let __v_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_7: G = __r_arr[0];
-        match __v_7.as_canonical_u64() {
-          1u64 => {
-            let __v_8: G = G::from_u64(1);
-            let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } else { aiur_fn_310(__args, record, io_buffer, __cu)? } };
-            let __v_9: G = __r_arr[0];
-            let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } };
-            let __v_10: G = __r_arr[0];
-            let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } else { aiur_fn_338(__args, record, io_buffer, __cu)? } };
-            let __v_11: G = __r_arr[0];
-            let __ret: [G; OUT_350] = [__v_8, __v_11];
-            record.function_queries[350].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          0u64 => {
-            let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[277].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_277] = unsafe { *(result.output.as_ptr() as *const [G; OUT_277]) }; __ret } else { aiur_fn_277(__args, record, io_buffer, __cu)? } };
-            let __v_8: G = __r_arr[0];
-            let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_9: G = __r_arr[0];
-            match __v_9.as_canonical_u64() {
+    let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } else { aiur_fn_255(__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 __v_13: G = __r_arr[10];
+    let __v_14: G = __r_arr[11];
+    let __v_15: G = __r_arr[12];
+    let __v_16: G = __r_arr[13];
+    let __v_17: G = __r_arr[14];
+    let __v_18: G = __r_arr[15];
+    let __v_19: G = __r_arr[16];
+    let __v_20: G = __r_arr[17];
+    let __v_21: G = __r_arr[18];
+    let __v_22: G = __r_arr[19];
+    let __v_23: G = __r_arr[20];
+    let __v_24: G = __r_arr[21];
+    let __v_25: G = __r_arr[22];
+    let __v_26: G = __r_arr[23];
+    let __v_27: G = __r_arr[24];
+    let __v_28: G = __r_arr[25];
+    let __v_29: G = __r_arr[26];
+    let __v_30: G = __r_arr[27];
+    let __v_31: G = __r_arr[28];
+    let __v_32: G = __r_arr[29];
+    let __v_33: G = __r_arr[30];
+    let __v_34: G = __r_arr[31];
+    let __v_35: G = __r_arr[32];
+    let __v_36: G = __r_arr[33];
+    let __v_37: G = __r_arr[34];
+    let __v_38: G = __r_arr[35];
+    let __v_39: G = __r_arr[36];
+    let __v_40: G = __r_arr[37];
+    let __v_41: G = __r_arr[38];
+    let __v_42: G = __r_arr[39];
+    let __v_43: G = __r_arr[40];
+    let __v_44: G = __r_arr[41];
+    let __v_45: G = __r_arr[42];
+    let __v_46: G = __r_arr[43];
+    let __v_47: G = __r_arr[44];
+    let __v_48: G = __r_arr[45];
+    let __v_49: G = __r_arr[46];
+    let __v_50: G = __r_arr[47];
+    match __v_3.as_canonical_u64() {
+      _ => {
+        match __v_3.as_canonical_u64() {
+          8u64 => {
+            let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[264].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_264] = unsafe { *(result.output.as_ptr() as *const [G; OUT_264]) }; __ret } else { aiur_fn_264(__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 __v_83: G = __r_arr[32];
+            let __v_84: G = __r_arr[33];
+            let __v_85: G = __r_arr[34];
+            let __v_86: G = __r_arr[35];
+            let __v_87: G = __r_arr[36];
+            let __v_88: G = __r_arr[37];
+            let __v_89: G = __r_arr[38];
+            let __v_90: G = __r_arr[39];
+            let __v_91: G = __r_arr[40];
+            let __v_92: G = __r_arr[41];
+            let __v_93: G = __r_arr[42];
+            let __v_94: G = __r_arr[43];
+            let __v_95: G = __r_arr[44];
+            match __v_51.as_canonical_u64() {
               1u64 => {
-                let __v_10: G = G::from_u64(1);
-                let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[316].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_316] = unsafe { *(result.output.as_ptr() as *const [G; OUT_316]) }; __ret } else { aiur_fn_316(__args, record, io_buffer, __cu)? } };
-                let __v_11: G = __r_arr[0];
-                let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } };
-                let __v_12: G = __r_arr[0];
-                let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } else { aiur_fn_338(__args, record, io_buffer, __cu)? } };
-                let __v_13: G = __r_arr[0];
-                let __ret: [G; OUT_350] = [__v_10, __v_13];
-                record.function_queries[350].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              0u64 => {
-                let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[281].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_281] = unsafe { *(result.output.as_ptr() as *const [G; OUT_281]) }; __ret } else { aiur_fn_281(__args, record, io_buffer, __cu)? } };
-                let __v_10: G = __r_arr[0];
-                let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_11: G = __r_arr[0];
-                match __v_11.as_canonical_u64() {
-                  1u64 => {
-                    let __v_12: G = G::from_u64(1);
-                    let __r_arr: [G; OUT_322] = { let __args: [G; IN_322] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[322].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_322] = unsafe { *(result.output.as_ptr() as *const [G; OUT_322]) }; __ret } else { aiur_fn_322(__args, record, io_buffer, __cu)? } };
-                    let __v_13: G = __r_arr[0];
-                    let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } };
-                    let __v_14: G = __r_arr[0];
-                    let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } else { aiur_fn_338(__args, record, io_buffer, __cu)? } };
-                    let __v_15: G = __r_arr[0];
-                    let __ret: [G; OUT_350] = [__v_12, __v_15];
-                    record.function_queries[350].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
-                  0u64 => {
-                    let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[280].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_280] = unsafe { *(result.output.as_ptr() as *const [G; OUT_280]) }; __ret } else { aiur_fn_280(__args, record, io_buffer, __cu)? } };
-                    let __v_12: G = __r_arr[0];
-                    let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_13: G = __r_arr[0];
-                    match __v_13.as_canonical_u64() {
-                      1u64 => {
-                        let __v_14: G = G::from_u64(1);
-                        let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } else { aiur_fn_323(__args, record, io_buffer, __cu)? } };
-                        let __v_15: G = __r_arr[0];
-                        let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } };
-                        let __v_16: G = __r_arr[0];
-                        let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } else { aiur_fn_338(__args, record, io_buffer, __cu)? } };
-                        let __v_17: G = __r_arr[0];
-                        let __ret: [G; OUT_350] = [__v_14, __v_17];
-                        record.function_queries[350].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                        return Ok(__ret);
-                      },
-                      0u64 => {
-                        let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } else { aiur_fn_279(__args, record, io_buffer, __cu)? } };
-                        let __v_14: G = __r_arr[0];
-                        let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_15: G = __r_arr[0];
-                        match __v_15.as_canonical_u64() {
-                          1u64 => {
-                            let __v_16: G = G::from_u64(1);
-                            let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } else { aiur_fn_324(__args, record, io_buffer, __cu)? } };
-                            let __v_17: G = __r_arr[0];
-                            let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } };
-                            let __v_18: G = __r_arr[0];
-                            let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } else { aiur_fn_338(__args, record, io_buffer, __cu)? } };
-                            let __v_19: G = __r_arr[0];
-                            let __ret: [G; OUT_350] = [__v_16, __v_19];
-                            record.function_queries[350].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                            return Ok(__ret);
-                          },
-                          0u64 => {
-                            let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } else { aiur_fn_278(__args, record, io_buffer, __cu)? } };
-                            let __v_16: G = __r_arr[0];
-                            let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_17: G = __r_arr[0];
-                            match __v_17.as_canonical_u64() {
-                              1u64 => {
-                                let __v_18: G = G::from_u64(1);
-                                let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[325].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_325] = unsafe { *(result.output.as_ptr() as *const [G; OUT_325]) }; __ret } else { aiur_fn_325(__args, record, io_buffer, __cu)? } };
-                                let __v_19: G = __r_arr[0];
-                                let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } };
-                                let __v_20: G = __r_arr[0];
-                                let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } else { aiur_fn_338(__args, record, io_buffer, __cu)? } };
-                                let __v_21: G = __r_arr[0];
-                                let __ret: [G; OUT_350] = [__v_18, __v_21];
-                                record.function_queries[350].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                return Ok(__ret);
-                              },
-                              0u64 => {
-                                let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } else { aiur_fn_282(__args, record, io_buffer, __cu)? } };
-                                let __v_18: G = __r_arr[0];
-                                let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_19: G = __r_arr[0];
-                                match __v_19.as_canonical_u64() {
-                                  1u64 => {
-                                    let __v_20: G = G::from_u64(1);
-                                    let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } else { aiur_fn_329(__args, record, io_buffer, __cu)? } };
-                                    let __v_21: G = __r_arr[0];
-                                    let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } };
-                                    let __v_22: G = __r_arr[0];
-                                    let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } else { aiur_fn_338(__args, record, io_buffer, __cu)? } };
-                                    let __v_23: G = __r_arr[0];
-                                    let __ret: [G; OUT_350] = [__v_20, __v_23];
-                                    record.function_queries[350].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                    return Ok(__ret);
-                                  },
-                                  0u64 => {
-                                    let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } else { aiur_fn_283(__args, record, io_buffer, __cu)? } };
-                                    let __v_20: G = __r_arr[0];
-                                    let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_21: G = __r_arr[0];
-                                    match __v_21.as_canonical_u64() {
-                                      1u64 => {
-                                        let __v_22: G = G::from_u64(1);
-                                        let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[330].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_330] = unsafe { *(result.output.as_ptr() as *const [G; OUT_330]) }; __ret } else { aiur_fn_330(__args, record, io_buffer, __cu)? } };
-                                        let __v_23: G = __r_arr[0];
-                                        let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } };
-                                        let __v_24: G = __r_arr[0];
-                                        let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } else { aiur_fn_338(__args, record, io_buffer, __cu)? } };
-                                        let __v_25: G = __r_arr[0];
-                                        let __ret: [G; OUT_350] = [__v_22, __v_25];
-                                        record.function_queries[350].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                        return Ok(__ret);
-                                      },
-                                      0u64 => {
-                                        let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } else { aiur_fn_284(__args, record, io_buffer, __cu)? } };
-                                        let __v_22: G = __r_arr[0];
-                                        let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_23: G = __r_arr[0];
-                                        match __v_23.as_canonical_u64() {
-                                          1u64 => {
-                                            let __v_24: G = G::from_u64(1);
-                                            let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[331].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_331] = unsafe { *(result.output.as_ptr() as *const [G; OUT_331]) }; __ret } else { aiur_fn_331(__args, record, io_buffer, __cu)? } };
-                                            let __v_25: G = __r_arr[0];
-                                            let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } };
-                                            let __v_26: G = __r_arr[0];
-                                            let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } else { aiur_fn_338(__args, record, io_buffer, __cu)? } };
-                                            let __v_27: G = __r_arr[0];
-                                            let __ret: [G; OUT_350] = [__v_24, __v_27];
-                                            record.function_queries[350].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                            return Ok(__ret);
-                                          },
-                                          0u64 => {
-                                            let __r_arr: [G; OUT_285] = { let __args: [G; IN_285] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[285].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_285] = unsafe { *(result.output.as_ptr() as *const [G; OUT_285]) }; __ret } else { aiur_fn_285(__args, record, io_buffer, __cu)? } };
-                                            let __v_24: G = __r_arr[0];
-                                            let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_25: G = __r_arr[0];
-                                            match __v_25.as_canonical_u64() {
-                                              1u64 => {
-                                                let __v_26: G = G::from_u64(1);
-                                                let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } else { aiur_fn_332(__args, record, io_buffer, __cu)? } };
-                                                let __v_27: G = __r_arr[0];
-                                                let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } };
-                                                let __v_28: G = __r_arr[0];
-                                                let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } else { aiur_fn_338(__args, record, io_buffer, __cu)? } };
-                                                let __v_29: G = __r_arr[0];
-                                                let __ret: [G; OUT_350] = [__v_26, __v_29];
-                                                record.function_queries[350].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                                return Ok(__ret);
-                                              },
-                                              0u64 => {
-                                                let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } else { aiur_fn_286(__args, record, io_buffer, __cu)? } };
-                                                let __v_26: G = __r_arr[0];
-                                                let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_27: G = __r_arr[0];
-                                                match __v_27.as_canonical_u64() {
-                                                  1u64 => {
-                                                    let __v_28: G = G::from_u64(1);
-                                                    let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } else { aiur_fn_333(__args, record, io_buffer, __cu)? } };
-                                                    let __v_29: G = __r_arr[0];
-                                                    let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } };
-                                                    let __v_30: G = __r_arr[0];
-                                                    let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } else { aiur_fn_338(__args, record, io_buffer, __cu)? } };
-                                                    let __v_31: G = __r_arr[0];
-                                                    let __ret: [G; OUT_350] = [__v_28, __v_31];
-                                                    record.function_queries[350].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                                    return Ok(__ret);
-                                                  },
-                                                  0u64 => {
-                                                    let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } else { aiur_fn_287(__args, record, io_buffer, __cu)? } };
-                                                    let __v_28: G = __r_arr[0];
-                                                    let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_29: G = __r_arr[0];
-                                                    match __v_29.as_canonical_u64() {
-                                                      1u64 => {
-                                                        let __v_30: G = G::from_u64(1);
-                                                        let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_230] = unsafe { *(result.output.as_ptr() as *const [G; OUT_230]) }; __ret } else { aiur_fn_230(__args, record, io_buffer, __cu)? } };
-                                                        let __v_31: G = __r_arr[0];
-                                                        let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_31, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[351].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_351] = unsafe { *(result.output.as_ptr() as *const [G; OUT_351]) }; __ret } else { aiur_fn_351(__args, record, io_buffer, __cu)? } };
-                                                        let __v_32: G = __r_arr[0];
-                                                        let __ret: [G; OUT_350] = [__v_30, __v_32];
-                                                        record.function_queries[350].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                                        return Ok(__ret);
-                                                      },
-                                                      0u64 => {
-                                                        let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[288].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_288] = unsafe { *(result.output.as_ptr() as *const [G; OUT_288]) }; __ret } else { aiur_fn_288(__args, record, io_buffer, __cu)? } };
-                                                        let __v_30: G = __r_arr[0];
-                                                        let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_31: G = __r_arr[0];
-                                                        match __v_31.as_canonical_u64() {
-                                                          1u64 => {
-                                                            let __v_32: G = G::from_u64(1);
-                                                            let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[311].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_311] = unsafe { *(result.output.as_ptr() as *const [G; OUT_311]) }; __ret } else { aiur_fn_311(__args, record, io_buffer, __cu)? } };
-                                                            let __v_33: G = __r_arr[0];
-                                                            let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_33, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[351].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_351] = unsafe { *(result.output.as_ptr() as *const [G; OUT_351]) }; __ret } else { aiur_fn_351(__args, record, io_buffer, __cu)? } };
-                                                            let __v_34: G = __r_arr[0];
-                                                            let __ret: [G; OUT_350] = [__v_32, __v_34];
-                                                            record.function_queries[350].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                                            return Ok(__ret);
-                                                          },
-                                                          0u64 => {
-                                                            let __v_32: G = G::from_u64(0);
-                                                            let __v_33: G = G::from_u64(0);
-                                                            let __v_34: G = G::from_u64(0);
-                                                            let __v_35: G = G::from_u64(0);
-                                                            let __v_36: G = { let __values: [G; 4] = [__v_33, __v_34, __v_35, __v_35]; 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_350] = [__v_32, __v_36];
-                                                            record.function_queries[350].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                                            return Ok(__ret);
-                                                          },
-                                                          _ => {
-                                                            return Err(ExecError::MatchNoCase(__v_31.as_canonical_u64()));
-                                                          },
-                                                        }
-                                                      },
-                                                      _ => {
-                                                        return Err(ExecError::MatchNoCase(__v_29.as_canonical_u64()));
-                                                      },
-                                                    }
-                                                  },
-                                                  _ => {
-                                                    return Err(ExecError::MatchNoCase(__v_27.as_canonical_u64()));
-                                                  },
-                                                }
-                                              },
-                                              _ => {
-                                                return Err(ExecError::MatchNoCase(__v_25.as_canonical_u64()));
-                                              },
-                                            }
-                                          },
-                                          _ => {
-                                            return Err(ExecError::MatchNoCase(__v_23.as_canonical_u64()));
-                                          },
-                                        }
-                                      },
-                                      _ => {
-                                        return Err(ExecError::MatchNoCase(__v_21.as_canonical_u64()));
-                                      },
-                                    }
-                                  },
-                                  _ => {
-                                    return Err(ExecError::MatchNoCase(__v_19.as_canonical_u64()));
-                                  },
-                                }
-                              },
-                              _ => {
-                                return Err(ExecError::MatchNoCase(__v_17.as_canonical_u64()));
-                              },
-                            }
-                          },
-                          _ => {
-                            return Err(ExecError::MatchNoCase(__v_15.as_canonical_u64()));
-                          },
-                        }
-                      },
-                      _ => {
-                        return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64()));
-                      },
-                    }
-                  },
+                match __v_52.as_canonical_u64() {
                   _ => {
-                    return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64()));
+                    let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_78, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[250].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_250] = unsafe { *(result.output.as_ptr() as *const [G; OUT_250]) }; __ret } else { aiur_fn_250(__args, record, io_buffer, __cu)? } };
+                    let __v_96: G = __r_arr[0];
+                    let __v_97: G = __r_arr[1];
+                    let __v_98: G = __r_arr[2];
+                    let __v_99: G = __r_arr[3];
+                    let __v_100: G = __r_arr[4];
+                    let __v_101: G = __r_arr[5];
+                    let __v_102: G = __r_arr[6];
+                    let __v_103: G = __r_arr[7];
+                    let __v_104: G = __r_arr[8];
+                    let __v_105: G = __r_arr[9];
+                    let __v_106: G = __r_arr[10];
+                    let __v_107: G = __r_arr[11];
+                    let __v_108: G = __r_arr[12];
+                    let __v_109: G = __r_arr[13];
+                    let __v_110: G = __r_arr[14];
+                    let __v_111: G = __r_arr[15];
+                    let __v_112: G = __r_arr[16];
+                    let __v_113: G = __r_arr[17];
+                    let __v_114: G = __r_arr[18];
+                    let __v_115: G = __r_arr[19];
+                    let __v_116: G = __r_arr[20];
+                    let __v_117: G = __r_arr[21];
+                    let __v_118: G = __r_arr[22];
+                    let __v_119: G = __r_arr[23];
+                    let __v_120: G = __r_arr[24];
+                    let __v_121: G = __r_arr[25];
+                    let __v_122: G = __r_arr[26];
+                    let __v_123: G = __r_arr[27];
+                    let __v_124: G = __r_arr[28];
+                    let __v_125: G = __r_arr[29];
+                    let __v_126: G = __r_arr[30];
+                    let __v_127: G = __r_arr[31];
+                    let __v_128: G = __r_arr[32];
+                    let __v_129: G = __r_arr[33];
+                    let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_4, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = unsafe { *(result.output.as_ptr() as *const [G; OUT_267]) }; __ret } else { aiur_fn_267(__args, record, io_buffer, __cu)? } };
+                    let __v_130: G = __r_arr[0];
+                    let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__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, __v_128, __v_129, __v_0, __v_1, __v_48, __v_49, __v_130, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } else { aiur_fn_252(__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 = { let __values: [G; 12] = [__v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_261] = [__v_143];
+                    record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
                   },
                 }
               },
               _ => {
-                return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64()));
+                return Err(ExecError::MatchNoCase(__v_51.as_canonical_u64()));
               },
             }
           },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64()));
+            return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
-      },
     }
   })
 }
 
-const INPUT_SIZE_351: usize = 2;
-const IN_351: usize = 2;
-const OUT_351: usize = 1;
-fn aiur_fn_351(
-  inp: [G; IN_351],
+const INPUT_SIZE_262: usize = 2;
+const IN_262: usize = 2;
+const OUT_262: usize = 1;
+fn aiur_fn_262(
+  inp: [G; IN_262],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_351], ExecError> {
+) -> Result<[G; OUT_262], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_0.as_canonical_u64() {
-  0u64 => {
-    let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[303].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_303] = unsafe { *(result.output.as_ptr() as *const [G; OUT_303]) }; __ret } else { aiur_fn_303(__args, record, io_buffer, __cu)? } };
-    let __v_2: G = __r_arr[0];
-    break '__mc_0 [__v_2];
-  },
-  _ => {
-    let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[302].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_302] = unsafe { *(result.output.as_ptr() as *const [G; OUT_302]) }; __ret } else { aiur_fn_302(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } else { aiur_fn_255(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
-    break '__mc_0 [__v_2];
-  },
-}
- };
-    let __v_2: G = __mc_out___mc_0[0];
-    let __v_3: G = G::from_u64(0);
-    let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_2, __v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } else { aiur_fn_334(__args, record, io_buffer, __cu)? } };
-    let __v_4: G = __r_arr[0];
-    let __v_5: G = __r_arr[1];
-    match __v_4.as_canonical_u64() {
-      1u64 => {
-        let __v_6: G = G::from_u64(2);
-        let __v_7: G = G::from_u64(1);
-        let __v_8: G = G::from_u64(1);
-        let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __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_10: G = G::from_u64(0);
-        let __v_11: G = { let __values: [G; 4] = [__v_6, __v_5, __v_9, __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_351] = [__v_11];
-        record.function_queries[351].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      0u64 => {
-        match __v_0.as_canonical_u64() {
-          0u64 => {
-            let __v_6: G = G::from_u64(7);
-            let __v_7: G = G::from_u64(0);
-            let __v_8: G = G::from_u64(1);
-            let __v_9: G = G::from_u64(1);
-            let __v_10: G = { let __values: [G; 10] = [__v_8, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9]; 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_11: G = G::from_u64(0);
-            let __v_12: G = { let __values: [G; 4] = [__v_6, __v_7, __v_10, __v_11]; 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_351] = [__v_12];
-            record.function_queries[351].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
+    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 = __r_arr[10];
+    let __v_13: G = __r_arr[11];
+    let __v_14: G = __r_arr[12];
+    let __v_15: G = __r_arr[13];
+    let __v_16: G = __r_arr[14];
+    let __v_17: G = __r_arr[15];
+    let __v_18: G = __r_arr[16];
+    let __v_19: G = __r_arr[17];
+    let __v_20: G = __r_arr[18];
+    let __v_21: G = __r_arr[19];
+    let __v_22: G = __r_arr[20];
+    let __v_23: G = __r_arr[21];
+    let __v_24: G = __r_arr[22];
+    let __v_25: G = __r_arr[23];
+    let __v_26: G = __r_arr[24];
+    let __v_27: G = __r_arr[25];
+    let __v_28: G = __r_arr[26];
+    let __v_29: G = __r_arr[27];
+    let __v_30: G = __r_arr[28];
+    let __v_31: G = __r_arr[29];
+    let __v_32: G = __r_arr[30];
+    let __v_33: G = __r_arr[31];
+    let __v_34: G = __r_arr[32];
+    let __v_35: G = __r_arr[33];
+    let __v_36: G = __r_arr[34];
+    let __v_37: G = __r_arr[35];
+    let __v_38: G = __r_arr[36];
+    let __v_39: G = __r_arr[37];
+    let __v_40: G = __r_arr[38];
+    let __v_41: G = __r_arr[39];
+    let __v_42: G = __r_arr[40];
+    let __v_43: G = __r_arr[41];
+    let __v_44: G = __r_arr[42];
+    let __v_45: G = __r_arr[43];
+    let __v_46: G = __r_arr[44];
+    let __v_47: G = __r_arr[45];
+    let __v_48: G = __r_arr[46];
+    let __v_49: G = __r_arr[47];
+    match __v_2.as_canonical_u64() {
+      _ => {
+        match __v_2.as_canonical_u64() {
+          8u64 => {
+            let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[264].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_264] = unsafe { *(result.output.as_ptr() as *const [G; OUT_264]) }; __ret } else { aiur_fn_264(__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 __v_61: G = __r_arr[11];
+            let __v_62: G = __r_arr[12];
+            let __v_63: G = __r_arr[13];
+            let __v_64: G = __r_arr[14];
+            let __v_65: G = __r_arr[15];
+            let __v_66: G = __r_arr[16];
+            let __v_67: G = __r_arr[17];
+            let __v_68: G = __r_arr[18];
+            let __v_69: G = __r_arr[19];
+            let __v_70: G = __r_arr[20];
+            let __v_71: G = __r_arr[21];
+            let __v_72: G = __r_arr[22];
+            let __v_73: G = __r_arr[23];
+            let __v_74: G = __r_arr[24];
+            let __v_75: G = __r_arr[25];
+            let __v_76: G = __r_arr[26];
+            let __v_77: G = __r_arr[27];
+            let __v_78: G = __r_arr[28];
+            let __v_79: G = __r_arr[29];
+            let __v_80: G = __r_arr[30];
+            let __v_81: G = __r_arr[31];
+            let __v_82: G = __r_arr[32];
+            let __v_83: G = __r_arr[33];
+            let __v_84: G = __r_arr[34];
+            let __v_85: G = __r_arr[35];
+            let __v_86: G = __r_arr[36];
+            let __v_87: G = __r_arr[37];
+            let __v_88: G = __r_arr[38];
+            let __v_89: G = __r_arr[39];
+            let __v_90: G = __r_arr[40];
+            let __v_91: G = __r_arr[41];
+            let __v_92: G = __r_arr[42];
+            let __v_93: G = __r_arr[43];
+            let __v_94: G = __r_arr[44];
+            match __v_50.as_canonical_u64() {
+              2u64 => {
+                let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_3, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = unsafe { *(result.output.as_ptr() as *const [G; OUT_267]) }; __ret } else { aiur_fn_267(__args, record, io_buffer, __cu)? } };
+                let __v_95: G = __r_arr[0];
+                let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__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_0, __v_1, __v_47, __v_48, __v_95, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } else { aiur_fn_254(__args, record, io_buffer, __cu)? } };
+                let __v_96: G = __r_arr[0];
+                let __v_97: G = __r_arr[1];
+                let __v_98: G = __r_arr[2];
+                let __v_99: G = __r_arr[3];
+                let __v_100: G = __r_arr[4];
+                let __v_101: G = __r_arr[5];
+                let __v_102: G = __r_arr[6];
+                let __v_103: G = __r_arr[7];
+                let __v_104: G = __r_arr[8];
+                let __v_105: G = __r_arr[9];
+                let __v_106: G = __r_arr[10];
+                let __v_107: G = __r_arr[11];
+                let __v_108: G = { let __values: [G; 12] = [__v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_262] = [__v_108];
+                record.function_queries[262].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                return Err(ExecError::MatchNoCase(__v_50.as_canonical_u64()));
+              },
+            }
           },
           _ => {
-            let __v_6: G = G::from_u64(7);
-            let __v_7: G = G::from_u64(0);
-            let __v_8: G = G::from_u64(0);
-            let __v_9: G = G::from_u64(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 = 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 = G::from_u64(1);
-            let __v_18: G = G::from_u64(1);
-            let __v_19: G = { let __values: [G; 10] = [__v_17, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18]; 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_20: G = { let __values: [G; 10] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_19]; 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_21: G = G::from_u64(0);
-            let __v_22: G = { let __values: [G; 4] = [__v_6, __v_7, __v_20, __v_21]; 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_351] = [__v_22];
-            record.function_queries[351].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
+            return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
-      },
     }
   })
 }
 
-const INPUT_SIZE_352: usize = 4;
-const IN_352: usize = 4;
-const OUT_352: usize = 2;
-fn aiur_fn_352(
-  inp: [G; IN_352],
+const INPUT_SIZE_263: usize = 3;
+const IN_263: usize = 3;
+const OUT_263: usize = 1;
+fn aiur_fn_263(
+  inp: [G; IN_263],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_352], ExecError> {
+) -> Result<[G; OUT_263], 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_187] = { let __args: [G; IN_187] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { 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_4: G = __r_arr[0];
-    let __v_5: G = G::from_u64(2);
-    let __v_6: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_5.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_6.as_canonical_u64() {
-      1u64 => {
-        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 = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __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_352] = [__v_7, __v_11];
-        record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __v_7: G = G::from_u64(0);
-        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-        let __v_8: G = __r_arr[0];
-        let __v_9: G = G::from_u64(1);
-        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-        let __v_10: G = __r_arr[0];
-        let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_10, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } };
-        let __v_11: G = __r_arr[0];
-        let __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = [__v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[353].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_353] = unsafe { *(result.output.as_ptr() as *const [G; OUT_353]) }; __ret } else { aiur_fn_353(__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];
-        match __v_12.as_canonical_u64() {
+    let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } else { aiur_fn_255(__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 __v_13: G = __r_arr[10];
+    let __v_14: G = __r_arr[11];
+    let __v_15: G = __r_arr[12];
+    let __v_16: G = __r_arr[13];
+    let __v_17: G = __r_arr[14];
+    let __v_18: G = __r_arr[15];
+    let __v_19: G = __r_arr[16];
+    let __v_20: G = __r_arr[17];
+    let __v_21: G = __r_arr[18];
+    let __v_22: G = __r_arr[19];
+    let __v_23: G = __r_arr[20];
+    let __v_24: G = __r_arr[21];
+    let __v_25: G = __r_arr[22];
+    let __v_26: G = __r_arr[23];
+    let __v_27: G = __r_arr[24];
+    let __v_28: G = __r_arr[25];
+    let __v_29: G = __r_arr[26];
+    let __v_30: G = __r_arr[27];
+    let __v_31: G = __r_arr[28];
+    let __v_32: G = __r_arr[29];
+    let __v_33: G = __r_arr[30];
+    let __v_34: G = __r_arr[31];
+    let __v_35: G = __r_arr[32];
+    let __v_36: G = __r_arr[33];
+    let __v_37: G = __r_arr[34];
+    let __v_38: G = __r_arr[35];
+    let __v_39: G = __r_arr[36];
+    let __v_40: G = __r_arr[37];
+    let __v_41: G = __r_arr[38];
+    let __v_42: G = __r_arr[39];
+    let __v_43: G = __r_arr[40];
+    let __v_44: G = __r_arr[41];
+    let __v_45: G = __r_arr[42];
+    let __v_46: G = __r_arr[43];
+    let __v_47: G = __r_arr[44];
+    let __v_48: G = __r_arr[45];
+    let __v_49: G = __r_arr[46];
+    let __v_50: G = __r_arr[47];
+    match __v_3.as_canonical_u64() {
+      _ => {
+        let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[264].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_264] = unsafe { *(result.output.as_ptr() as *const [G; OUT_264]) }; __ret } else { aiur_fn_264(__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 __v_83: G = __r_arr[32];
+        let __v_84: G = __r_arr[33];
+        let __v_85: G = __r_arr[34];
+        let __v_86: G = __r_arr[35];
+        let __v_87: G = __r_arr[36];
+        let __v_88: G = __r_arr[37];
+        let __v_89: G = __r_arr[38];
+        let __v_90: G = __r_arr[39];
+        let __v_91: G = __r_arr[40];
+        let __v_92: G = __r_arr[41];
+        let __v_93: G = __r_arr[42];
+        let __v_94: G = __r_arr[43];
+        let __v_95: G = __r_arr[44];
+        let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_1, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = unsafe { *(result.output.as_ptr() as *const [G; OUT_267]) }; __ret } else { aiur_fn_267(__args, record, io_buffer, __cu)? } };
+        let __v_96: G = __r_arr[0];
+        match __v_51.as_canonical_u64() {
           0u64 => {
-            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 = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; 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_352] = [__v_15, __v_19];
-            record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[256].get_mut(&__args[..]) { let __ret: [G; OUT_256] = unsafe { *(result.output.as_ptr() as *const [G; OUT_256]) }; __ret } else { aiur_fn_256(__args, record, io_buffer, __cu)? } };
+            let __v_97: G = __r_arr[0];
+            let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__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_48, __v_49, __v_96, __v_50, __v_97]; let __cu = unconstrained; if let Some(result) = record.function_queries[246].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_246] = unsafe { *(result.output.as_ptr() as *const [G; OUT_246]) }; __ret } else { aiur_fn_246(__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 __v_101: G = __r_arr[3];
+            let __v_102: G = __r_arr[4];
+            let __v_103: G = __r_arr[5];
+            let __v_104: G = __r_arr[6];
+            let __v_105: G = __r_arr[7];
+            let __v_106: G = __r_arr[8];
+            let __v_107: G = __r_arr[9];
+            let __v_108: G = __r_arr[10];
+            let __v_109: G = __r_arr[11];
+            let __v_110: G = { let __values: [G; 12] = [__v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_263] = [__v_110];
+            record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
-            let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_14, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } };
-            let __v_15: G = __r_arr[0];
-            let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_15, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } else { aiur_fn_336(__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() {
-              0u64 => {
-                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 = { let __values: [G; 4] = [__v_19, __v_20, __v_21, __v_21]; 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_352] = [__v_18, __v_22];
-                record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              1u64 => {
-                let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_13, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } };
-                let __v_18: G = __r_arr[0];
-                let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_18, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } else { aiur_fn_336(__args, record, io_buffer, __cu)? } };
-                let __v_19: G = __r_arr[0];
-                let __v_20: G = __r_arr[1];
-                match __v_19.as_canonical_u64() {
-                  0u64 => {
-                    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 __v_24: G = G::from_u64(0);
-                    let __v_25: G = { let __values: [G; 4] = [__v_22, __v_23, __v_24, __v_24]; 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_352] = [__v_21, __v_25];
-                    record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
-                  1u64 => {
-                    let __v_21: G = G::from_u64(0);
-                    let __v_22: G = G::from_u64(2);
-                    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 __v_26: G = G::from_u64(0);
-                    let __v_27: G = G::from_u64(0);
-                    let __v_28: G = G::from_u64(0);
-                    let __v_29: G = G::from_u64(0);
-                    let __v_30: G = G::from_u64(1);
-                    let __v_31: G = G::from_u64(1);
-                    let __v_32: G = { let __values: [G; 10] = [__v_30, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31]; 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_33: G = { let __values: [G; 10] = [__v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_32]; 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_325] = { let __args: [G; IN_325] = [__v_33, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[325].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_325] = unsafe { *(result.output.as_ptr() as *const [G; OUT_325]) }; __ret } else { aiur_fn_325(__args, record, io_buffer, __cu)? } };
-                    let __v_34: G = __r_arr[0];
-                    let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_17, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } else { aiur_fn_323(__args, record, io_buffer, __cu)? } };
-                    let __v_35: G = __r_arr[0];
-                    let __v_36: G = G::from_u64(1);
-                    let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } else { aiur_fn_338(__args, record, io_buffer, __cu)? } };
-                    let __v_37: G = __r_arr[0];
-                    let __ret: [G; OUT_352] = [__v_36, __v_37];
-                    record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
-                  _ => {
-                    return Err(ExecError::MatchNoCase(__v_19.as_canonical_u64()));
-                  },
-                }
-              },
-              _ => {
-                return Err(ExecError::MatchNoCase(__v_16.as_canonical_u64()));
-              },
-            }
+            let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__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_0, __v_2, __v_48, __v_49, __v_96, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } else { aiur_fn_251(__args, record, io_buffer, __cu)? } };
+            let __v_97: G = __r_arr[0];
+            let __v_98: G = __r_arr[1];
+            let __v_99: G = __r_arr[2];
+            let __v_100: G = __r_arr[3];
+            let __v_101: G = __r_arr[4];
+            let __v_102: G = __r_arr[5];
+            let __v_103: G = __r_arr[6];
+            let __v_104: G = __r_arr[7];
+            let __v_105: G = __r_arr[8];
+            let __v_106: G = __r_arr[9];
+            let __v_107: G = __r_arr[10];
+            let __v_108: G = __r_arr[11];
+            let __v_109: G = { let __values: [G; 12] = [__v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_263] = [__v_109];
+            record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          2u64 => {
+            let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__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_0, __v_2, __v_48, __v_49, __v_96, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } else { aiur_fn_254(__args, record, io_buffer, __cu)? } };
+            let __v_97: G = __r_arr[0];
+            let __v_98: G = __r_arr[1];
+            let __v_99: G = __r_arr[2];
+            let __v_100: G = __r_arr[3];
+            let __v_101: G = __r_arr[4];
+            let __v_102: G = __r_arr[5];
+            let __v_103: G = __r_arr[6];
+            let __v_104: G = __r_arr[7];
+            let __v_105: G = __r_arr[8];
+            let __v_106: G = __r_arr[9];
+            let __v_107: G = __r_arr[10];
+            let __v_108: G = __r_arr[11];
+            let __v_109: G = { let __values: [G; 12] = [__v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_263] = [__v_109];
+            record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
           },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64()));
+            return Err(ExecError::MatchNoCase(__v_51.as_canonical_u64()));
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64()));
-      },
     }
   })
 }
 
-const INPUT_SIZE_353: usize = 2;
-const IN_353: usize = 2;
-const OUT_353: usize = 3;
-fn aiur_fn_353(
-  inp: [G; IN_353],
+const INPUT_SIZE_264: usize = 2;
+const IN_264: usize = 2;
+const OUT_264: usize = 45;
+fn aiur_fn_264(
+  inp: [G; IN_264],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_353], ExecError> {
+) -> Result<[G; OUT_264], 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_189] = { let __args: [G; IN_189] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[189].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_189] = unsafe { *(result.output.as_ptr() as *const [G; OUT_189]) }; __ret } else { aiur_fn_189(__args, record, io_buffer, __cu)? } };
-    let __v_2: G = __r_arr[0];
-    let __v_3: G = __r_arr[1];
-    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_4: G = __loaded[0];
-    let __v_5: G = __loaded[1];
-    let __v_6: G = __loaded[2];
-    let __v_7: G = __loaded[3];
-    match __v_4.as_canonical_u64() {
-      2u64 => {
-        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-        let __v_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } else { aiur_fn_239(__args, record, io_buffer, __cu)? } };
-        let __v_9: G = __r_arr[0];
-        let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_10: G = __r_arr[0];
-        match __v_10.as_canonical_u64() {
-          1u64 => {
-            let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { 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_11: G = __r_arr[0];
-            let __v_12: G = G::from_u64(2);
-            let __v_13: G = (__v_11 - __v_12);
-            match __v_13.as_canonical_u64() {
-              0u64 => {
-                let __v_14: G = G::from_u64(1);
-                let __v_15: G = G::from_u64(0);
-                let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-                let __v_16: G = __r_arr[0];
-                let __v_17: G = G::from_u64(1);
-                let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_3, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-                let __v_18: G = __r_arr[0];
-                let __ret: [G; OUT_353] = [__v_14, __v_16, __v_18];
-                record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              _ => {
-                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 = G::from_u64(0);
-                let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; 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_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 = { let __values: [G; 4] = [__v_19, __v_20, __v_21, __v_21]; 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_353] = [__v_14, __v_18, __v_22];
-                record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-            }
-          },
+    let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; 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: 47 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 47] = __args[..47].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];
+    let __v_12: G = __loaded[10];
+    let __v_13: G = __loaded[11];
+    let __v_14: G = __loaded[12];
+    let __v_15: G = __loaded[13];
+    let __v_16: G = __loaded[14];
+    let __v_17: G = __loaded[15];
+    let __v_18: G = __loaded[16];
+    let __v_19: G = __loaded[17];
+    let __v_20: G = __loaded[18];
+    let __v_21: G = __loaded[19];
+    let __v_22: G = __loaded[20];
+    let __v_23: G = __loaded[21];
+    let __v_24: G = __loaded[22];
+    let __v_25: G = __loaded[23];
+    let __v_26: G = __loaded[24];
+    let __v_27: G = __loaded[25];
+    let __v_28: G = __loaded[26];
+    let __v_29: G = __loaded[27];
+    let __v_30: G = __loaded[28];
+    let __v_31: G = __loaded[29];
+    let __v_32: G = __loaded[30];
+    let __v_33: G = __loaded[31];
+    let __v_34: G = __loaded[32];
+    let __v_35: G = __loaded[33];
+    let __v_36: G = __loaded[34];
+    let __v_37: G = __loaded[35];
+    let __v_38: G = __loaded[36];
+    let __v_39: G = __loaded[37];
+    let __v_40: G = __loaded[38];
+    let __v_41: G = __loaded[39];
+    let __v_42: G = __loaded[40];
+    let __v_43: G = __loaded[41];
+    let __v_44: G = __loaded[42];
+    let __v_45: G = __loaded[43];
+    let __v_46: G = __loaded[44];
+    let __v_47: G = __loaded[45];
+    let __v_48: G = __loaded[46];
+    match __v_2.as_canonical_u64() {
+      0u64 => {
+        match __v_1.as_canonical_u64() {
           0u64 => {
-            let __v_11: G = G::from_u64(143);
-            let __v_12: G = G::from_u64(220);
-            let __v_13: G = G::from_u64(134);
-            let __v_14: G = G::from_u64(159);
-            let __v_15: G = G::from_u64(123);
-            let __v_16: G = G::from_u64(122);
-            let __v_17: G = G::from_u64(162);
-            let __v_18: G = G::from_u64(183);
-            let __v_19: G = G::from_u64(181);
-            let __v_20: G = G::from_u64(146);
-            let __v_21: G = G::from_u64(155);
-            let __v_22: G = G::from_u64(162);
-            let __v_23: G = G::from_u64(66);
-            let __v_24: G = G::from_u64(237);
-            let __v_25: G = G::from_u64(137);
-            let __v_26: G = G::from_u64(156);
-            let __v_27: G = G::from_u64(226);
-            let __v_28: G = G::from_u64(215);
-            let __v_29: G = G::from_u64(197);
-            let __v_30: G = G::from_u64(212);
-            let __v_31: G = G::from_u64(45);
-            let __v_32: G = G::from_u64(241);
-            let __v_33: G = G::from_u64(212);
-            let __v_34: G = G::from_u64(226);
-            let __v_35: G = G::from_u64(57);
-            let __v_36: G = G::from_u64(54);
-            let __v_37: G = G::from_u64(144);
-            let __v_38: G = G::from_u64(207);
-            let __v_39: G = G::from_u64(168);
-            let __v_40: G = G::from_u64(94);
-            let __v_41: G = G::from_u64(148);
-            let __v_42: G = G::from_u64(210);
-            let __v_43: G = { let __values: [G; 32] = [__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]; 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_122] = { let __args: [G; IN_122] = [__v_8, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_44: G = __r_arr[0];
-            match __v_44.as_canonical_u64() {
-              0u64 => {
-                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 = { let __values: [G; 4] = [__v_46, __v_47, __v_48, __v_48]; 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_50: G = G::from_u64(0);
-                let __v_51: G = G::from_u64(0);
-                let __v_52: G = G::from_u64(0);
-                let __v_53: G = { let __values: [G; 4] = [__v_50, __v_51, __v_52, __v_52]; 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_353] = [__v_45, __v_49, __v_53];
-                record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              1u64 => {
-                let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { 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_45: G = __r_arr[0];
-                let __v_46: G = G::from_u64(2);
-                let __v_47: G = { let __a_val = __v_45.as_canonical_u64(); let __b_val = __v_46.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_47.as_canonical_u64() {
-                  1u64 => {
-                    let __v_48: G = G::from_u64(0);
-                    let __v_49: G = G::from_u64(0);
-                    let __v_50: G = G::from_u64(0);
-                    let __v_51: G = G::from_u64(0);
-                    let __v_52: G = { let __values: [G; 4] = [__v_49, __v_50, __v_51, __v_51]; 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_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 = { let __values: [G; 4] = [__v_53, __v_54, __v_55, __v_55]; 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_353] = [__v_48, __v_52, __v_56];
-                    record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
-                  0u64 => {
-                    let __v_48: G = G::from_u64(0);
-                    let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_3, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-                    let __v_49: G = __r_arr[0];
-                    let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[189].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_189] = unsafe { *(result.output.as_ptr() as *const [G; OUT_189]) }; __ret } else { aiur_fn_189(__args, record, io_buffer, __cu)? } };
-                    let __v_50: G = __r_arr[0];
-                    let __v_51: G = __r_arr[1];
-                    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_50.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).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_52: G = __loaded[0];
-                    let __v_53: G = __loaded[1];
-                    let __v_54: G = __loaded[2];
-                    let __v_55: G = __loaded[3];
-                    match __v_52.as_canonical_u64() {
-                      2u64 => {
-                        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_1, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-                        let __v_56: G = __r_arr[0];
-                        let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[237].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_237] = unsafe { *(result.output.as_ptr() as *const [G; OUT_237]) }; __ret } else { aiur_fn_237(__args, record, io_buffer, __cu)? } };
-                        let __v_57: G = __r_arr[0];
-                        let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_56, __v_57]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_58: G = __r_arr[0];
-                        match __v_58.as_canonical_u64() {
-                          0u64 => {
-                            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 = { let __values: [G; 4] = [__v_60, __v_61, __v_62, __v_62]; 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_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 = { let __values: [G; 4] = [__v_64, __v_65, __v_66, __v_66]; 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_353] = [__v_59, __v_63, __v_67];
-                            record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                            return Ok(__ret);
-                          },
-                          1u64 => {
-                            let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { 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_59: G = __r_arr[0];
-                            let __v_60: G = G::from_u64(1);
-                            let __v_61: G = (__v_59 - __v_60);
-                            match __v_61.as_canonical_u64() {
-                              0u64 => {
-                                let __v_62: G = G::from_u64(1);
-                                let __v_63: G = G::from_u64(0);
-                                let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_51, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-                                let __v_64: G = __r_arr[0];
-                                let __v_65: G = G::from_u64(1);
-                                let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_3, __v_65]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-                                let __v_66: G = __r_arr[0];
-                                let __ret: [G; OUT_353] = [__v_62, __v_64, __v_66];
-                                record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                return Ok(__ret);
-                              },
-                              _ => {
-                                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 = { let __values: [G; 4] = [__v_63, __v_64, __v_65, __v_65]; 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_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 = { let __values: [G; 4] = [__v_67, __v_68, __v_69, __v_69]; 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_353] = [__v_62, __v_66, __v_70];
-                                record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                return Ok(__ret);
-                              },
-                            }
-                          },
-                          _ => {
-                            return Err(ExecError::MatchNoCase(__v_58.as_canonical_u64()));
-                          },
-                        }
-                      },
-                      _ => {
-                        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 = { let __values: [G; 4] = [__v_57, __v_58, __v_59, __v_59]; 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_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; 4] = [__v_61, __v_62, __v_63, __v_63]; 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_353] = [__v_56, __v_60, __v_64];
-                        record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                        return Ok(__ret);
-                      },
-                    }
-                  },
-                  _ => {
-                    return Err(ExecError::MatchNoCase(__v_47.as_canonical_u64()));
-                  },
-                }
-              },
-              _ => {
-                return Err(ExecError::MatchNoCase(__v_44.as_canonical_u64()));
-              },
-            }
+            let __ret: [G; OUT_264] = [__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_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];
+            record.function_queries[264].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
           },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64()));
+            let __v_49: G = G::from_u64(1);
+            let __v_50: G = (__v_1 - __v_49);
+            let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = [__v_48, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[264].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_264] = unsafe { *(result.output.as_ptr() as *const [G; OUT_264]) }; __ret } else { aiur_fn_264(__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 __v_83: G = __r_arr[32];
+            let __v_84: G = __r_arr[33];
+            let __v_85: G = __r_arr[34];
+            let __v_86: G = __r_arr[35];
+            let __v_87: G = __r_arr[36];
+            let __v_88: G = __r_arr[37];
+            let __v_89: G = __r_arr[38];
+            let __v_90: G = __r_arr[39];
+            let __v_91: G = __r_arr[40];
+            let __v_92: G = __r_arr[41];
+            let __v_93: G = __r_arr[42];
+            let __v_94: G = __r_arr[43];
+            let __v_95: G = __r_arr[44];
+            let __ret: [G; OUT_264] = [__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];
+            record.function_queries[264].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(0);
-        let __v_10: G = G::from_u64(0);
-        let __v_11: G = G::from_u64(0);
-        let __v_12: G = { let __values: [G; 4] = [__v_9, __v_10, __v_11, __v_11]; 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_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 = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; 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_353] = [__v_8, __v_12, __v_16];
-        record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_354: usize = 4;
-const IN_354: usize = 4;
-const OUT_354: usize = 2;
-fn aiur_fn_354(
-  inp: [G; IN_354],
+const INPUT_SIZE_265: usize = 1;
+const IN_265: usize = 1;
+const OUT_265: usize = 8;
+fn aiur_fn_265(
+  inp: [G; IN_265],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_354], ExecError> {
+) -> Result<[G; OUT_265], 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();
+    let __v_1: G = G::from_u8(__gb[0]);
+    let __v_2: G = G::from_u8(__gb[1]);
+    let __v_3: G = G::from_u8(__gb[2]);
+    let __v_4: G = G::from_u8(__gb[3]);
+    let __v_5: G = G::from_u8(__gb[4]);
+    let __v_6: G = G::from_u8(__gb[5]);
+    let __v_7: G = G::from_u8(__gb[6]);
+    let __v_8: G = G::from_u8(__gb[7]);
+    if !unconstrained { let __vi = __v_1; let __vj = __v_2; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); 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_3; let __vj = __v_4; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); 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_5; let __vj = __v_6; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); 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_7; let __vj = __v_8; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); 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 __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__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[15].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } else { aiur_fn_15(__args, record, io_buffer, __cu)? } };
+    let __v_9: G = __r_arr[0];
+    if (__v_9 != __v_0) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_0.as_canonical_u64(), msg: Some("projection index bytes do not recompose to the index".to_string()) });
+    }
+    let __ret: [G; OUT_265] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8];
+    record.function_queries[265].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_266: usize = 3;
+const IN_266: usize = 3;
+const OUT_266: usize = 1;
+fn aiur_fn_266(
+  inp: [G; IN_266],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_266], 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_264] = { let __args: [G; IN_264] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[264].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_264] = unsafe { *(result.output.as_ptr() as *const [G; OUT_264]) }; __ret } else { aiur_fn_264(__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 __v_13: G = __r_arr[10];
+    let __v_14: G = __r_arr[11];
+    let __v_15: G = __r_arr[12];
+    let __v_16: G = __r_arr[13];
+    let __v_17: G = __r_arr[14];
+    let __v_18: G = __r_arr[15];
+    let __v_19: G = __r_arr[16];
+    let __v_20: G = __r_arr[17];
+    let __v_21: G = __r_arr[18];
+    let __v_22: G = __r_arr[19];
+    let __v_23: G = __r_arr[20];
+    let __v_24: G = __r_arr[21];
+    let __v_25: G = __r_arr[22];
+    let __v_26: G = __r_arr[23];
+    let __v_27: G = __r_arr[24];
+    let __v_28: G = __r_arr[25];
+    let __v_29: G = __r_arr[26];
+    let __v_30: G = __r_arr[27];
+    let __v_31: G = __r_arr[28];
+    let __v_32: G = __r_arr[29];
+    let __v_33: G = __r_arr[30];
+    let __v_34: G = __r_arr[31];
+    let __v_35: G = __r_arr[32];
+    let __v_36: G = __r_arr[33];
+    let __v_37: G = __r_arr[34];
+    let __v_38: G = __r_arr[35];
+    let __v_39: G = __r_arr[36];
+    let __v_40: G = __r_arr[37];
+    let __v_41: G = __r_arr[38];
+    let __v_42: G = __r_arr[39];
+    let __v_43: G = __r_arr[40];
+    let __v_44: G = __r_arr[41];
+    let __v_45: G = __r_arr[42];
+    let __v_46: G = __r_arr[43];
+    let __v_47: G = __r_arr[44];
+    let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[265].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_265] = unsafe { *(result.output.as_ptr() as *const [G; OUT_265]) }; __ret } else { aiur_fn_265(__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];
+    let __v_51: G = __r_arr[3];
+    let __v_52: G = __r_arr[4];
+    let __v_53: G = __r_arr[5];
+    let __v_54: G = __r_arr[6];
+    let __v_55: G = __r_arr[7];
+    let __mc_out___mc_0: [G; 45] = '__mc_0: { match __v_3.as_canonical_u64() {
+  0u64 => {
+    let __v_56: G = G::from_u64(7);
+    let __v_57: G = G::from_u64(0);
+    break '__mc_0 [__v_56, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_1, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57];
+  },
+  1u64 => {
+    let __v_56: G = G::from_u64(6);
+    let __v_57: G = G::from_u64(0);
+    break '__mc_0 [__v_56, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_1, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57];
+  },
+  2u64 => {
+    let __v_56: G = G::from_u64(5);
+    let __v_57: G = G::from_u64(0);
+    break '__mc_0 [__v_56, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_1, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57, __v_57];
+  },
+  _ => {
+    return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
+  },
+}
+ };
+    let __v_56: G = __mc_out___mc_0[0];
+    let __v_57: G = __mc_out___mc_0[1];
+    let __v_58: G = __mc_out___mc_0[2];
+    let __v_59: G = __mc_out___mc_0[3];
+    let __v_60: G = __mc_out___mc_0[4];
+    let __v_61: G = __mc_out___mc_0[5];
+    let __v_62: G = __mc_out___mc_0[6];
+    let __v_63: G = __mc_out___mc_0[7];
+    let __v_64: G = __mc_out___mc_0[8];
+    let __v_65: G = __mc_out___mc_0[9];
+    let __v_66: G = __mc_out___mc_0[10];
+    let __v_67: G = __mc_out___mc_0[11];
+    let __v_68: G = __mc_out___mc_0[12];
+    let __v_69: G = __mc_out___mc_0[13];
+    let __v_70: G = __mc_out___mc_0[14];
+    let __v_71: G = __mc_out___mc_0[15];
+    let __v_72: G = __mc_out___mc_0[16];
+    let __v_73: G = __mc_out___mc_0[17];
+    let __v_74: G = __mc_out___mc_0[18];
+    let __v_75: G = __mc_out___mc_0[19];
+    let __v_76: G = __mc_out___mc_0[20];
+    let __v_77: G = __mc_out___mc_0[21];
+    let __v_78: G = __mc_out___mc_0[22];
+    let __v_79: G = __mc_out___mc_0[23];
+    let __v_80: G = __mc_out___mc_0[24];
+    let __v_81: G = __mc_out___mc_0[25];
+    let __v_82: G = __mc_out___mc_0[26];
+    let __v_83: G = __mc_out___mc_0[27];
+    let __v_84: G = __mc_out___mc_0[28];
+    let __v_85: G = __mc_out___mc_0[29];
+    let __v_86: G = __mc_out___mc_0[30];
+    let __v_87: G = __mc_out___mc_0[31];
+    let __v_88: G = __mc_out___mc_0[32];
+    let __v_89: G = __mc_out___mc_0[33];
+    let __v_90: G = __mc_out___mc_0[34];
+    let __v_91: G = __mc_out___mc_0[35];
+    let __v_92: G = __mc_out___mc_0[36];
+    let __v_93: G = __mc_out___mc_0[37];
+    let __v_94: G = __mc_out___mc_0[38];
+    let __v_95: G = __mc_out___mc_0[39];
+    let __v_96: G = __mc_out___mc_0[40];
+    let __v_97: G = __mc_out___mc_0[41];
+    let __v_98: G = __mc_out___mc_0[42];
+    let __v_99: G = __mc_out___mc_0[43];
+    let __v_100: G = __mc_out___mc_0[44];
+    let __v_101: G = G::from_u64(1);
+    let __v_102: G = G::from_u64(1);
+    let __v_103: G = { let __values: [G; 3] = [__v_101, __v_102, __v_102]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    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 __v_107: G = G::from_u64(1);
+    let __v_108: G = G::from_u64(1);
+    let __v_109: G = { let __values: [G; 3] = [__v_107, __v_108, __v_108]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_110: G = G::from_u64(1);
+    let __v_111: G = G::from_u64(1);
+    let __v_112: G = { let __values: [G; 3] = [__v_110, __v_111, __v_111]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_67] = { let __args: [G; IN_67] = [__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_103, __v_106, __v_109, __v_112]; let __cu = unconstrained; if let Some(result) = record.function_queries[67].get_mut(&__args[..]) { 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_113: G = __r_arr[0];
+    let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_113]; let __cu = unconstrained; if let Some(result) = record.function_queries[18].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_18] = unsafe { *(result.output.as_ptr() as *const [G; OUT_18]) }; __ret } else { aiur_fn_18(__args, record, io_buffer, __cu)? } };
+    let __v_114: G = __r_arr[0];
+    let __ret: [G; OUT_266] = [__v_114];
+    record.function_queries[266].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_267: usize = 2;
+const IN_267: usize = 2;
+const OUT_267: usize = 1;
+fn aiur_fn_267(
+  inp: [G; IN_267],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_267], 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(0);
+    let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_0, __v_1, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } else { aiur_fn_268(__args, record, io_buffer, __cu)? } };
+    let __v_3: G = __r_arr[0];
+    let __ret: [G; OUT_267] = [__v_3];
+    record.function_queries[267].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_268: usize = 4;
+const IN_268: usize = 4;
+const OUT_268: usize = 1;
+fn aiur_fn_268(
+  inp: [G; IN_268],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_268], 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_187] = { let __args: [G; IN_187] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { 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_4: G = __r_arr[0];
-    let __v_5: G = G::from_u64(3);
-    let __v_6: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_5.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_6.as_canonical_u64() {
+    let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; 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: 47 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr };
+    let __v_4: G = __loaded[0];
+    let __v_5: G = __loaded[1];
+    let __v_6: G = __loaded[2];
+    let __v_7: G = __loaded[3];
+    let __v_8: G = __loaded[4];
+    let __v_9: G = __loaded[5];
+    let __v_10: G = __loaded[6];
+    let __v_11: G = __loaded[7];
+    let __v_12: G = __loaded[8];
+    let __v_13: G = __loaded[9];
+    let __v_14: G = __loaded[10];
+    let __v_15: G = __loaded[11];
+    let __v_16: G = __loaded[12];
+    let __v_17: G = __loaded[13];
+    let __v_18: G = __loaded[14];
+    let __v_19: G = __loaded[15];
+    let __v_20: G = __loaded[16];
+    let __v_21: G = __loaded[17];
+    let __v_22: G = __loaded[18];
+    let __v_23: G = __loaded[19];
+    let __v_24: G = __loaded[20];
+    let __v_25: G = __loaded[21];
+    let __v_26: G = __loaded[22];
+    let __v_27: G = __loaded[23];
+    let __v_28: G = __loaded[24];
+    let __v_29: G = __loaded[25];
+    let __v_30: G = __loaded[26];
+    let __v_31: G = __loaded[27];
+    let __v_32: G = __loaded[28];
+    let __v_33: G = __loaded[29];
+    let __v_34: G = __loaded[30];
+    let __v_35: G = __loaded[31];
+    let __v_36: G = __loaded[32];
+    let __v_37: G = __loaded[33];
+    let __v_38: G = __loaded[34];
+    let __v_39: G = __loaded[35];
+    let __v_40: G = __loaded[36];
+    let __v_41: G = __loaded[37];
+    let __v_42: G = __loaded[38];
+    let __v_43: G = __loaded[39];
+    let __v_44: G = __loaded[40];
+    let __v_45: G = __loaded[41];
+    let __v_46: G = __loaded[42];
+    let __v_47: G = __loaded[43];
+    let __v_48: G = __loaded[44];
+    let __v_49: G = __loaded[45];
+    let __v_50: G = __loaded[46];
+    match __v_4.as_canonical_u64() {
       1u64 => {
-        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 = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __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_354] = [__v_7, __v_11];
-        record.function_queries[354].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __v_51: G = G::from_u64(1);
+        let __v_52: G = G::from_u64(1);
+        let __v_53: G = { let __values: [G; 3] = [__v_51, __v_52, __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 __ret: [G; OUT_268] = [__v_53];
+        record.function_queries[268].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __v_7: G = G::from_u64(0);
-        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-        let __v_8: G = __r_arr[0];
-        let __v_9: G = G::from_u64(1);
-        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-        let __v_10: G = __r_arr[0];
-        let __v_11: G = G::from_u64(2);
-        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-        let __v_12: G = __r_arr[0];
-        let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_8, __v_10, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } else { aiur_fn_355(__args, record, io_buffer, __cu)? } };
-        let __v_13: G = __r_arr[0];
-        let __v_14: G = __r_arr[1];
-        let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_8, __v_12, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } else { aiur_fn_355(__args, record, io_buffer, __cu)? } };
-        let __v_15: G = __r_arr[0];
-        let __v_16: G = __r_arr[1];
-        match __v_13.as_canonical_u64() {
-          0u64 => {
-            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 = { let __values: [G; 4] = [__v_18, __v_19, __v_20, __v_20]; 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_354] = [__v_17, __v_21];
-            record.function_queries[354].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          1u64 => {
-            match __v_15.as_canonical_u64() {
-              0u64 => {
-                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 = { let __values: [G; 4] = [__v_18, __v_19, __v_20, __v_20]; 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_354] = [__v_17, __v_21];
-                record.function_queries[354].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              1u64 => {
-                let __v_17: G = G::from_u64(1);
-                let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_16, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[311].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_311] = unsafe { *(result.output.as_ptr() as *const [G; OUT_311]) }; __ret } else { aiur_fn_311(__args, record, io_buffer, __cu)? } };
-                let __v_18: G = __r_arr[0];
-                let __v_19: G = (__v_17 - __v_18);
-                let __v_20: G = G::from_u64(1);
-                let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_19, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[351].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_351] = unsafe { *(result.output.as_ptr() as *const [G; OUT_351]) }; __ret } else { aiur_fn_351(__args, record, io_buffer, __cu)? } };
-                let __v_21: G = __r_arr[0];
-                let __ret: [G; OUT_354] = [__v_20, __v_21];
-                record.function_queries[354].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              _ => {
-                return Err(ExecError::MatchNoCase(__v_15.as_canonical_u64()));
-              },
-            }
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64()));
-          },
-        }
+        let __v_51: G = G::from_u64(0);
+        let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[266].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_266] = unsafe { *(result.output.as_ptr() as *const [G; OUT_266]) }; __ret } else { aiur_fn_266(__args, record, io_buffer, __cu)? } };
+        let __v_52: G = __r_arr[0];
+        let __v_53: G = G::from_u64(1);
+        let __v_54: G = (__v_3 + __v_53);
+        let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_0, __v_1, __v_50, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } else { aiur_fn_268(__args, record, io_buffer, __cu)? } };
+        let __v_55: G = __r_arr[0];
+        let __v_56: G = { let __values: [G; 3] = [__v_51, __v_52, __v_55]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_268] = [__v_56];
+        record.function_queries[268].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64()));
+        return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_355: usize = 5;
-const IN_355: usize = 5;
-const OUT_355: usize = 2;
-fn aiur_fn_355(
-  inp: [G; IN_355],
+const INPUT_SIZE_269: usize = 1;
+const IN_269: usize = 1;
+const OUT_269: usize = 1;
+fn aiur_fn_269(
+  inp: [G; IN_269],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_355], ExecError> {
+) -> Result<[G; OUT_269], 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(1);
-    let __v_8: G = G::from_u64(1);
-    let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __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_10: G = { let __values: [G; 3] = [__v_6, __v_1, __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_5, __v_0, __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_352] = { let __args: [G; IN_352] = [__v_11, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[352].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_352] = unsafe { *(result.output.as_ptr() as *const [G; OUT_352]) }; __ret } else { aiur_fn_352(__args, record, io_buffer, __cu)? } };
-    let __v_12: G = __r_arr[0];
-    let __v_13: G = __r_arr[1];
-    match __v_12.as_canonical_u64() {
+    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_14: G = G::from_u64(0);
-        let __v_15: G = G::from_u64(1);
-        let __v_16: G = G::from_u64(1);
-        let __v_17: G = { let __values: [G; 10] = [__v_15, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16]; 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_355] = [__v_14, __v_17];
-        record.function_queries[355].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __v_4: G = G::from_u64(0);
+        let __ret: [G; OUT_269] = [__v_4];
+        record.function_queries[269].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      4u64 => {
+        let __v_4: G = G::from_u64(0);
+        let __ret: [G; OUT_269] = [__v_4];
+        record.function_queries[269].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; 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: 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() {
-          7u64 => {
-            match __v_15.as_canonical_u64() {
+        let __v_4: G = G::from_u64(1);
+        let __ret: [G; OUT_269] = [__v_4];
+        record.function_queries[269].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      2u64 => {
+        let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } else { aiur_fn_269(__args, record, io_buffer, __cu)? } };
+        let __v_4: G = __r_arr[0];
+        let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } else { aiur_fn_269(__args, record, io_buffer, __cu)? } };
+        let __v_5: G = __r_arr[0];
+        match __v_4.as_canonical_u64() {
+          0u64 => {
+            match __v_5.as_canonical_u64() {
               0u64 => {
-                let __v_18: G = G::from_u64(1);
-                let __ret: [G; OUT_355] = [__v_18, __v_16];
-                record.function_queries[355].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __v_6: G = G::from_u64(0);
+                let __ret: [G; OUT_269] = [__v_6];
+                record.function_queries[269].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                let __v_18: G = G::from_u64(0);
-                let __v_19: G = G::from_u64(1);
-                let __v_20: G = G::from_u64(1);
-                let __v_21: G = { let __values: [G; 10] = [__v_19, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20]; 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_355] = [__v_18, __v_21];
-                record.function_queries[355].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __v_6: G = G::from_u64(1);
+                let __ret: [G; OUT_269] = [__v_6];
+                record.function_queries[269].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
           _ => {
-            let __v_18: G = G::from_u64(0);
-            let __v_19: G = G::from_u64(1);
-            let __v_20: G = G::from_u64(1);
-            let __v_21: G = { let __values: [G; 10] = [__v_19, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20]; 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_355] = [__v_18, __v_21];
-            record.function_queries[355].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __v_6: G = G::from_u64(1);
+            let __ret: [G; OUT_269] = [__v_6];
+            record.function_queries[269].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
+      3u64 => {
+        let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } else { aiur_fn_269(__args, record, io_buffer, __cu)? } };
+        let __v_4: G = __r_arr[0];
+        let __ret: [G; OUT_269] = [__v_4];
+        record.function_queries[269].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64()));
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_356: usize = 5;
-const IN_356: usize = 5;
-const OUT_356: usize = 2;
-fn aiur_fn_356(
-  inp: [G; IN_356],
+const INPUT_SIZE_270: usize = 2;
+const IN_270: usize = 2;
+const OUT_270: usize = 1;
+fn aiur_fn_270(
+  inp: [G; IN_270],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_356], ExecError> {
+) -> Result<[G; OUT_270], 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_238] = { let __args: [G; IN_238] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[238].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_238] = unsafe { *(result.output.as_ptr() as *const [G; OUT_238]) }; __ret } else { aiur_fn_238(__args, record, io_buffer, __cu)? } };
-    let __v_5: G = __r_arr[0];
-    let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_6: G = __r_arr[0];
-    match __v_6.as_canonical_u64() {
-      1u64 => {
-        let __r_arr: [G; OUT_352] = { let __args: [G; IN_352] = [__v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[352].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_352] = unsafe { *(result.output.as_ptr() as *const [G; OUT_352]) }; __ret } else { aiur_fn_352(__args, record, io_buffer, __cu)? } };
-        let __v_7: G = __r_arr[0];
-        let __v_8: G = __r_arr[1];
-        let __ret: [G; OUT_356] = [__v_7, __v_8];
-        record.function_queries[356].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 __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[240].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_240] = unsafe { *(result.output.as_ptr() as *const [G; OUT_240]) }; __ret } else { aiur_fn_240(__args, record, io_buffer, __cu)? } };
-        let __v_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_8: G = __r_arr[0];
-        match __v_8.as_canonical_u64() {
+        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_5: G = __loaded[0];
+        let __v_6: G = __loaded[1];
+        let __v_7: G = __loaded[2];
+        match __v_5.as_canonical_u64() {
+          0u64 => {
+            let __v_8: G = G::from_u64(1);
+            let __ret: [G; OUT_270] = [__v_8];
+            record.function_queries[270].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            let __v_8: G = G::from_u64(0);
+            let __ret: [G; OUT_270] = [__v_8];
+            record.function_queries[270].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_5: G = __loaded[0];
+        let __v_6: G = __loaded[1];
+        let __v_7: G = __loaded[2];
+        match __v_5.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[354].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_354] = unsafe { *(result.output.as_ptr() as *const [G; OUT_354]) }; __ret } else { aiur_fn_354(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[270].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_270] = unsafe { *(result.output.as_ptr() as *const [G; OUT_270]) }; __ret } else { aiur_fn_270(__args, record, io_buffer, __cu)? } };
+            let __v_8: G = __r_arr[0];
+            let __ret: [G; OUT_270] = [__v_8];
+            record.function_queries[270].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            let __v_8: G = G::from_u64(0);
+            let __ret: [G; OUT_270] = [__v_8];
+            record.function_queries[270].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+        }
+      },
+      2u64 => {
+        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_5: G = __loaded[0];
+        let __v_6: G = __loaded[1];
+        let __v_7: G = __loaded[2];
+        match __v_5.as_canonical_u64() {
+          2u64 => {
+            let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[270].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_270] = unsafe { *(result.output.as_ptr() as *const [G; OUT_270]) }; __ret } else { aiur_fn_270(__args, record, io_buffer, __cu)? } };
+            let __v_8: G = __r_arr[0];
+            let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[270].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_270] = unsafe { *(result.output.as_ptr() as *const [G; OUT_270]) }; __ret } else { aiur_fn_270(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
-            let __v_10: G = __r_arr[1];
-            let __ret: [G; OUT_356] = [__v_9, __v_10];
-            record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __v_10: G = (__v_8 * __v_9);
+            let __ret: [G; OUT_270] = [__v_10];
+            record.function_queries[270].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
-          0u64 => {
-            let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } else { aiur_fn_241(__args, record, io_buffer, __cu)? } };
+          _ => {
+            let __v_8: G = G::from_u64(0);
+            let __ret: [G; OUT_270] = [__v_8];
+            record.function_queries[270].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+        }
+      },
+      3u64 => {
+        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_5: G = __loaded[0];
+        let __v_6: G = __loaded[1];
+        let __v_7: G = __loaded[2];
+        match __v_5.as_canonical_u64() {
+          3u64 => {
+            let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[270].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_270] = unsafe { *(result.output.as_ptr() as *const [G; OUT_270]) }; __ret } else { aiur_fn_270(__args, record, io_buffer, __cu)? } };
+            let __v_8: G = __r_arr[0];
+            let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[270].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_270] = unsafe { *(result.output.as_ptr() as *const [G; OUT_270]) }; __ret } else { aiur_fn_270(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
-            let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_10: G = __r_arr[0];
-            match __v_10.as_canonical_u64() {
-              1u64 => {
-                let __r_arr: [G; OUT_357] = { let __args: [G; IN_357] = [__v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[357].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_357] = unsafe { *(result.output.as_ptr() as *const [G; OUT_357]) }; __ret } else { aiur_fn_357(__args, record, io_buffer, __cu)? } };
-                let __v_11: G = __r_arr[0];
-                let __v_12: G = __r_arr[1];
-                let __ret: [G; OUT_356] = [__v_11, __v_12];
-                record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              0u64 => {
-                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 = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; 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_356] = [__v_11, __v_15];
-                record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              _ => {
-                return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64()));
-              },
-            }
+            let __v_10: G = (__v_8 * __v_9);
+            let __ret: [G; OUT_270] = [__v_10];
+            record.function_queries[270].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
           },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64()));
+            let __v_8: G = G::from_u64(0);
+            let __ret: [G; OUT_270] = [__v_8];
+            record.function_queries[270].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+        }
+      },
+      4u64 => {
+        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_5: G = __loaded[0];
+        let __v_6: G = __loaded[1];
+        let __v_7: G = __loaded[2];
+        match __v_5.as_canonical_u64() {
+          4u64 => {
+            let __v_8: G = (__v_3 - __v_6);
+            let __v_9: G = G::from_bool((__v_8 == G::ZERO));
+            let __ret: [G; OUT_270] = [__v_9];
+            record.function_queries[270].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            let __v_8: G = G::from_u64(0);
+            let __ret: [G; OUT_270] = [__v_8];
+            record.function_queries[270].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
           },
         }
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64()));
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_357: usize = 4;
-const IN_357: usize = 4;
-const OUT_357: usize = 2;
-fn aiur_fn_357(
-  inp: [G; IN_357],
+const INPUT_SIZE_271: usize = 2;
+const IN_271: usize = 2;
+const OUT_271: usize = 1;
+fn aiur_fn_271(
+  inp: [G; IN_271],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_357], ExecError> {
+) -> Result<[G; OUT_271], 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_187] = { let __args: [G; IN_187] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { 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_4: G = __r_arr[0];
-    let __v_5: G = G::from_u64(2);
-    let __v_6: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_5.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_6.as_canonical_u64() {
+    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_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 = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __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_357] = [__v_7, __v_11];
-        record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __v_7: G = G::from_u64(0);
-        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-        let __v_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[189].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_189] = unsafe { *(result.output.as_ptr() as *const [G; OUT_189]) }; __ret } else { aiur_fn_189(__args, record, io_buffer, __cu)? } };
-        let __v_9: G = __r_arr[0];
-        let __v_10: G = __r_arr[1];
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; 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: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].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];
-        match __v_11.as_canonical_u64() {
-          2u64 => {
-            let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_3, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-            let __v_15: G = __r_arr[0];
-            let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } else { aiur_fn_242(__args, record, io_buffer, __cu)? } };
-            let __v_16: G = __r_arr[0];
-            let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_17: G = __r_arr[0];
-            match __v_17.as_canonical_u64() {
-              0u64 => {
-                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 = { let __values: [G; 4] = [__v_19, __v_20, __v_21, __v_21]; 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_357] = [__v_18, __v_22];
-                record.function_queries[357].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_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_5: G = __loaded[0];
+        let __v_6: G = __loaded[1];
+        let __v_7: G = __loaded[2];
+        match __v_5.as_canonical_u64() {
+          1u64 => {
+            let __v_8: G = G::from_u64(0);
+            let __ret: [G; OUT_271] = [__v_8];
+            record.function_queries[271].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          0u64 => {
+            let __v_8: G = G::from_u64(1);
+            let __ret: [G; OUT_271] = [__v_8];
+            record.function_queries[271].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__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_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_5: G = __loaded[0];
+        let __v_6: G = __loaded[1];
+        let __v_7: G = __loaded[2];
+        match __v_5.as_canonical_u64() {
+          1u64 => {
+            let __v_8: G = G::from_u64(2);
+            let __ret: [G; OUT_271] = [__v_8];
+            record.function_queries[271].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          0u64 => {
+            let __v_8: G = { let __a_val = __v_3.as_canonical_u64(); let __b_val = __v_6.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_8.as_canonical_u64() {
+              1u64 => {
+                let __v_9: G = G::from_u64(1);
+                let __ret: [G; OUT_271] = [__v_9];
+                record.function_queries[271].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
-              1u64 => {
-                let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { 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_18: G = __r_arr[0];
-                let __v_19: G = G::from_u64(4);
-                let __v_20: G = { let __a_val = __v_18.as_canonical_u64(); let __b_val = __v_19.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_20.as_canonical_u64() {
+              0u64 => {
+                let __v_9: G = { let __a_val = __v_6.as_canonical_u64(); let __b_val = __v_3.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_9.as_canonical_u64() {
                   1u64 => {
-                    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 __v_24: G = G::from_u64(0);
-                    let __v_25: G = { let __values: [G; 4] = [__v_22, __v_23, __v_24, __v_24]; 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_357] = [__v_21, __v_25];
-                    record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __v_10: G = G::from_u64(2);
+                    let __ret: [G; OUT_271] = [__v_10];
+                    record.function_queries[271].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   0u64 => {
-                    let __v_21: G = G::from_u64(0);
-                    let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_10, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-                    let __v_22: G = __r_arr[0];
-                    let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[189].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_189] = unsafe { *(result.output.as_ptr() as *const [G; OUT_189]) }; __ret } else { aiur_fn_189(__args, record, io_buffer, __cu)? } };
-                    let __v_23: G = __r_arr[0];
-                    let __v_24: G = __r_arr[1];
-                    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_23.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).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() {
-                      2u64 => {
-                        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_3, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-                        let __v_29: G = __r_arr[0];
-                        let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[237].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_237] = unsafe { *(result.output.as_ptr() as *const [G; OUT_237]) }; __ret } else { aiur_fn_237(__args, record, io_buffer, __cu)? } };
-                        let __v_30: G = __r_arr[0];
-                        let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_29, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_31: G = __r_arr[0];
-                        match __v_31.as_canonical_u64() {
-                          0u64 => {
-                            let __v_32: G = G::from_u64(0);
-                            let __v_33: G = G::from_u64(0);
-                            let __v_34: G = G::from_u64(0);
-                            let __v_35: G = G::from_u64(0);
-                            let __v_36: G = { let __values: [G; 4] = [__v_33, __v_34, __v_35, __v_35]; 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_357] = [__v_32, __v_36];
-                            record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                            return Ok(__ret);
-                          },
-                          1u64 => {
-                            let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { 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_32: G = __r_arr[0];
-                            let __v_33: G = G::from_u64(1);
-                            let __v_34: G = { let __a_val = __v_32.as_canonical_u64(); let __b_val = __v_33.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_34.as_canonical_u64() {
-                              1u64 => {
-                                let __v_35: G = G::from_u64(0);
-                                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 = { let __values: [G; 4] = [__v_36, __v_37, __v_38, __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_357] = [__v_35, __v_39];
-                                record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                return Ok(__ret);
-                              },
-                              0u64 => {
-                                let __v_35: G = G::from_u64(0);
-                                let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_24, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-                                let __v_36: G = __r_arr[0];
-                                let __v_37: G = G::from_u64(2);
-                                let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_10, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-                                let __v_38: G = __r_arr[0];
-                                let __v_39: G = G::from_u64(3);
-                                let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_10, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-                                let __v_40: G = __r_arr[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(1);
-                                let __v_45: G = G::from_u64(1);
-                                let __v_46: G = { let __values: [G; 3] = [__v_44, __v_45, __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_43, __v_40, __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_42, __v_38, __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_41, __v_36, __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 __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_49, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[354].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_354] = unsafe { *(result.output.as_ptr() as *const [G; OUT_354]) }; __ret } else { aiur_fn_354(__args, record, io_buffer, __cu)? } };
-                                let __v_50: G = __r_arr[0];
-                                let __v_51: G = __r_arr[1];
-                                let __ret: [G; OUT_357] = [__v_50, __v_51];
-                                record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                return Ok(__ret);
-                              },
-                              _ => {
-                                return Err(ExecError::MatchNoCase(__v_34.as_canonical_u64()));
-                              },
-                            }
-                          },
-                          _ => {
-                            return Err(ExecError::MatchNoCase(__v_31.as_canonical_u64()));
-                          },
-                        }
-                      },
-                      _ => {
-                        let __v_29: G = G::from_u64(0);
-                        let __v_30: G = G::from_u64(0);
-                        let __v_31: G = G::from_u64(0);
-                        let __v_32: G = G::from_u64(0);
-                        let __v_33: G = { let __values: [G; 4] = [__v_30, __v_31, __v_32, __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 __ret: [G; OUT_357] = [__v_29, __v_33];
-                        record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                        return Ok(__ret);
-                      },
-                    }
+                    let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[271].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_271] = unsafe { *(result.output.as_ptr() as *const [G; OUT_271]) }; __ret } else { aiur_fn_271(__args, record, io_buffer, __cu)? } };
+                    let __v_10: G = __r_arr[0];
+                    let __ret: [G; OUT_271] = [__v_10];
+                    record.function_queries[271].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
                   },
                   _ => {
-                    return Err(ExecError::MatchNoCase(__v_20.as_canonical_u64()));
+                    return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64()));
                   },
                 }
               },
               _ => {
-                return Err(ExecError::MatchNoCase(__v_17.as_canonical_u64()));
+                return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64()));
               },
             }
           },
           _ => {
-            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 = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; 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_357] = [__v_15, __v_19];
-            record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
+            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
           },
         }
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64()));
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_358: usize = 5;
-const IN_358: usize = 5;
-const OUT_358: usize = 2;
-fn aiur_fn_358(
-  inp: [G; IN_358],
+const INPUT_SIZE_272: usize = 2;
+const IN_272: usize = 2;
+const OUT_272: usize = 1;
+fn aiur_fn_272(
+  inp: [G; IN_272],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_358], ExecError> {
+) -> Result<[G; OUT_272], 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_264] = { let __args: [G; IN_264] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[264].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_264] = unsafe { *(result.output.as_ptr() as *const [G; OUT_264]) }; __ret } else { aiur_fn_264(__args, record, io_buffer, __cu)? } };
-    let __v_5: G = __r_arr[0];
-    let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_6: G = __r_arr[0];
-    match __v_6.as_canonical_u64() {
+    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_7: G = G::from_u64(1);
-        let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } else { aiur_fn_359(__args, record, io_buffer, __cu)? } };
-        let __v_8: G = __r_arr[0];
-        let __ret: [G; OUT_358] = [__v_7, __v_8];
-        record.function_queries[358].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __v_5: G = G::from_u64(1);
+        let __ret: [G; OUT_272] = [__v_5];
+        record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[266].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_266] = unsafe { *(result.output.as_ptr() as *const [G; OUT_266]) }; __ret } else { aiur_fn_266(__args, record, io_buffer, __cu)? } };
-        let __v_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_8: G = __r_arr[0];
-        match __v_8.as_canonical_u64() {
+        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_5: G = __loaded[0];
+        let __v_6: G = __loaded[1];
+        let __v_7: G = __loaded[2];
+        match __v_5.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[361].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_361] = unsafe { *(result.output.as_ptr() as *const [G; OUT_361]) }; __ret } else { aiur_fn_361(__args, record, io_buffer, __cu)? } };
-            let __v_9: G = __r_arr[0];
-            let __v_10: G = __r_arr[1];
-            let __ret: [G; OUT_358] = [__v_9, __v_10];
-            record.function_queries[358].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __v_8: G = G::from_u64(0);
+            let __ret: [G; OUT_272] = [__v_8];
+            record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } else { aiur_fn_268(__args, record, io_buffer, __cu)? } };
-            let __v_9: G = __r_arr[0];
-            let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_10: G = __r_arr[0];
-            match __v_10.as_canonical_u64() {
+            let __v_8: G = { let __a_val = __v_3.as_canonical_u64(); let __b_val = __v_6.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_8.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[362].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_362] = unsafe { *(result.output.as_ptr() as *const [G; OUT_362]) }; __ret } else { aiur_fn_362(__args, record, io_buffer, __cu)? } };
-                let __v_11: G = __r_arr[0];
-                let __v_12: G = __r_arr[1];
-                let __ret: [G; OUT_358] = [__v_11, __v_12];
-                record.function_queries[358].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __v_9: G = G::from_u64(0);
+                let __ret: [G; OUT_272] = [__v_9];
+                record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               0u64 => {
-                let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = unsafe { *(result.output.as_ptr() as *const [G; OUT_267]) }; __ret } else { aiur_fn_267(__args, record, io_buffer, __cu)? } };
-                let __v_11: G = __r_arr[0];
-                let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_12: G = __r_arr[0];
-                match __v_12.as_canonical_u64() {
+                let __v_9: G = { let __a_val = __v_6.as_canonical_u64(); let __b_val = __v_3.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_9.as_canonical_u64() {
                   1u64 => {
-                    let __v_13: G = G::from_u64(1);
-                    let __r_arr: [G; OUT_360] = { let __args: [G; IN_360] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[360].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_360] = unsafe { *(result.output.as_ptr() as *const [G; OUT_360]) }; __ret } else { aiur_fn_360(__args, record, io_buffer, __cu)? } };
-                    let __v_14: G = __r_arr[0];
-                    let __ret: [G; OUT_358] = [__v_13, __v_14];
-                    record.function_queries[358].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } else { aiur_fn_272(__args, record, io_buffer, __cu)? } };
+                    let __v_10: G = __r_arr[0];
+                    let __ret: [G; OUT_272] = [__v_10];
+                    record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   0u64 => {
-                    let __r_arr: [G; OUT_262] = { let __args: [G; IN_262] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[262].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_262] = unsafe { *(result.output.as_ptr() as *const [G; OUT_262]) }; __ret } else { aiur_fn_262(__args, record, io_buffer, __cu)? } };
-                    let __v_13: G = __r_arr[0];
-                    let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_14: G = __r_arr[0];
-                    let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[263].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_263] = unsafe { *(result.output.as_ptr() as *const [G; OUT_263]) }; __ret } else { aiur_fn_263(__args, record, io_buffer, __cu)? } };
-                    let __v_15: G = __r_arr[0];
-                    let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_16: G = __r_arr[0];
-                    let __v_17: G = (__v_14 + __v_16);
-                    match __v_17.as_canonical_u64() {
-                      0u64 => {
-                        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 = { let __values: [G; 4] = [__v_19, __v_20, __v_21, __v_21]; 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_358] = [__v_18, __v_22];
-                        record.function_queries[358].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                        return Ok(__ret);
-                      },
-                      _ => {
-                        let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { 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_18: G = __r_arr[0];
-                        let __v_19: G = G::from_u64(1);
-                        let __v_20: G = { let __a_val = __v_18.as_canonical_u64(); let __b_val = __v_19.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_20.as_canonical_u64() {
-                          1u64 => {
-                            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 __v_24: G = G::from_u64(0);
-                            let __v_25: G = { let __values: [G; 4] = [__v_22, __v_23, __v_24, __v_24]; 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_358] = [__v_21, __v_25];
-                            record.function_queries[358].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                            return Ok(__ret);
-                          },
-                          0u64 => {
-                            let __v_21: G = G::from_u64(0);
-                            let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_1, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-                            let __v_22: G = __r_arr[0];
-                            let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_22, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } };
-                            let __v_23: G = __r_arr[0];
-                            match __v_14.as_canonical_u64() {
-                              1u64 => {
-                                let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_23, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[363].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_363] = unsafe { *(result.output.as_ptr() as *const [G; OUT_363]) }; __ret } else { aiur_fn_363(__args, record, io_buffer, __cu)? } };
-                                let __v_24: G = __r_arr[0];
-                                let __v_25: G = __r_arr[1];
-                                let __ret: [G; OUT_358] = [__v_24, __v_25];
-                                record.function_queries[358].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                return Ok(__ret);
-                              },
-                              0u64 => {
-                                let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } else { aiur_fn_364(__args, record, io_buffer, __cu)? } };
-                                let __v_24: G = __r_arr[0];
-                                let __v_25: G = __r_arr[1];
-                                let __ret: [G; OUT_358] = [__v_24, __v_25];
-                                record.function_queries[358].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                return Ok(__ret);
-                              },
-                              _ => {
-                                return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64()));
-                              },
-                            }
-                          },
-                          _ => {
-                            return Err(ExecError::MatchNoCase(__v_20.as_canonical_u64()));
-                          },
-                        }
-                      },
-                    }
+                    let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } else { aiur_fn_272(__args, record, io_buffer, __cu)? } };
+                    let __v_10: G = __r_arr[0];
+                    let __ret: [G; OUT_272] = [__v_10];
+                    record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
                   },
                   _ => {
-                    return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64()));
+                    return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64()));
                   },
                 }
               },
               _ => {
-                return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64()));
+                return Err(ExecError::MatchNoCase(__v_8.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_6.as_canonical_u64()));
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_359: usize = 0;
-const IN_359: usize = 0;
-const OUT_359: usize = 1;
-fn aiur_fn_359(
-  inp: [G; IN_359],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_359], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(0);
-    let __v_1: G = G::from_u64(64);
-    let __v_2: G = G::from_u64(0);
-    let __v_3: G = G::from_u64(0);
-    let __v_4: G = G::from_u64(0);
-    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(1);
-    let __v_10: G = G::from_u64(1);
-    let __v_11: G = { let __values: [G; 10] = [__v_9, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10]; 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_12: G = { let __values: [G; 10] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_11]; 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_13: G = G::from_u64(7);
-    let __v_14: G = G::from_u64(0);
-    let __v_15: G = G::from_u64(0);
-    let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_12, __v_15]; 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_359] = [__v_16];
-    record.function_queries[359].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_360: usize = 0;
-const IN_360: usize = 0;
-const OUT_360: usize = 1;
-fn aiur_fn_360(
-  inp: [G; IN_360],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_360], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(0);
-    let __v_1: G = G::from_u64(1);
-    let __v_2: G = G::from_u64(0);
-    let __v_3: G = G::from_u64(0);
-    let __v_4: G = G::from_u64(0);
-    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(1);
-    let __v_10: G = G::from_u64(1);
-    let __v_11: G = { let __values: [G; 10] = [__v_9, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10]; 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_12: G = { let __values: [G; 10] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_11]; 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_13: G = G::from_u64(7);
-    let __v_14: G = G::from_u64(0);
-    let __v_15: G = G::from_u64(0);
-    let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_12, __v_15]; 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_360] = [__v_16];
-    record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_361: usize = 2;
-const IN_361: usize = 2;
-const OUT_361: usize = 2;
-fn aiur_fn_361(
-  inp: [G; IN_361],
+const INPUT_SIZE_273: usize = 2;
+const IN_273: usize = 2;
+const OUT_273: usize = 1;
+fn aiur_fn_273(
+  inp: [G; IN_273],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_361], ExecError> {
+) -> Result<[G; OUT_273], 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_187] = { let __args: [G; IN_187] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { 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_2: G = __r_arr[0];
-    let __v_3: G = G::from_u64(3);
-    let __v_4: G = { let __a_val = __v_2.as_canonical_u64(); let __b_val = __v_3.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_4.as_canonical_u64() {
+    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 __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; 4] = [__v_6, __v_7, __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_361] = [__v_5, __v_9];
-        record.function_queries[361].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_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_5: G = __loaded[0];
+        let __v_6: G = __loaded[1];
+        let __v_7: G = __loaded[2];
+        match __v_5.as_canonical_u64() {
+          1u64 => {
+            let __v_8: G = G::from_u64(1);
+            let __ret: [G; OUT_273] = [__v_8];
+            record.function_queries[273].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          0u64 => {
+            let __v_8: G = G::from_u64(0);
+            let __ret: [G; OUT_273] = [__v_8];
+            record.function_queries[273].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
+          },
+        }
       },
       0u64 => {
-        let __v_5: G = G::from_u64(2);
-        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-        let __v_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[189].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_189] = unsafe { *(result.output.as_ptr() as *const [G; OUT_189]) }; __ret } else { aiur_fn_189(__args, record, io_buffer, __cu)? } };
-        let __v_7: G = __r_arr[0];
-        let __v_8: G = __r_arr[1];
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; 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: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].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];
-        match __v_9.as_canonical_u64() {
-          2u64 => {
-            let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-            let __v_13: G = __r_arr[0];
-            let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[265].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_265] = unsafe { *(result.output.as_ptr() as *const [G; OUT_265]) }; __ret } else { aiur_fn_265(__args, record, io_buffer, __cu)? } };
-            let __v_14: G = __r_arr[0];
-            let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_15: G = __r_arr[0];
-            match __v_15.as_canonical_u64() {
-              1u64 => {
-                let __v_16: G = G::from_u64(1);
-                let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } else { aiur_fn_359(__args, record, io_buffer, __cu)? } };
-                let __v_17: G = __r_arr[0];
-                let __ret: [G; OUT_361] = [__v_16, __v_17];
-                record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              0u64 => {
-                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 = { let __values: [G; 4] = [__v_17, __v_18, __v_19, __v_19]; 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_361] = [__v_16, __v_20];
-                record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              _ => {
-                return Err(ExecError::MatchNoCase(__v_15.as_canonical_u64()));
-              },
-            }
+        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_5: G = __loaded[0];
+        let __v_6: G = __loaded[1];
+        let __v_7: G = __loaded[2];
+        match __v_5.as_canonical_u64() {
+          1u64 => {
+            let __v_8: G = G::from_u64(0);
+            let __ret: [G; OUT_273] = [__v_8];
+            record.function_queries[273].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
           },
-          _ => {
-            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; 4] = [__v_14, __v_15, __v_16, __v_16]; 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_361] = [__v_13, __v_17];
-            record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+          0u64 => {
+            let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[273].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_273] = unsafe { *(result.output.as_ptr() as *const [G; OUT_273]) }; __ret } else { aiur_fn_273(__args, record, io_buffer, __cu)? } };
+            let __v_8: G = __r_arr[0];
+            let __ret: [G; OUT_273] = [__v_8];
+            record.function_queries[273].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
+          },
         }
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_362: usize = 2;
-const IN_362: usize = 2;
-const OUT_362: usize = 2;
-fn aiur_fn_362(
-  inp: [G; IN_362],
+const INPUT_SIZE_274: usize = 2;
+const IN_274: usize = 2;
+const OUT_274: usize = 2;
+fn aiur_fn_274(
+  inp: [G; IN_274],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_362], ExecError> {
+) -> Result<[G; OUT_274], 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_187] = { let __args: [G; IN_187] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { 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_2: G = __r_arr[0];
-    let __v_3: G = G::from_u64(1);
-    let __v_4: G = { let __a_val = __v_2.as_canonical_u64(); let __b_val = __v_3.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_4.as_canonical_u64() {
+    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(0);
+        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 = { let __values: [G; 4] = [__v_6, __v_7, __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_362] = [__v_5, __v_9];
-        record.function_queries[362].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __v_7: G = G::from_u64(1);
+        let __v_8: G = G::from_u64(1);
+        let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __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_10: G = { let __values: [G; 3] = [__v_6, __v_0, __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 __ret: [G; OUT_274] = [__v_5, __v_10];
+        record.function_queries[274].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __v_5: G = G::from_u64(0);
-        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-        let __v_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[189].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_189] = unsafe { *(result.output.as_ptr() as *const [G; OUT_189]) }; __ret } else { aiur_fn_189(__args, record, io_buffer, __cu)? } };
-        let __v_7: G = __r_arr[0];
-        let __v_8: G = __r_arr[1];
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; 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: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].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];
-        match __v_9.as_canonical_u64() {
-          2u64 => {
-            let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-            let __v_13: G = __r_arr[0];
-            let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[270].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_270] = unsafe { *(result.output.as_ptr() as *const [G; OUT_270]) }; __ret } else { aiur_fn_270(__args, record, io_buffer, __cu)? } };
-            let __v_14: G = __r_arr[0];
-            let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_15: G = __r_arr[0];
-            let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } else { aiur_fn_269(__args, record, io_buffer, __cu)? } };
-            let __v_16: G = __r_arr[0];
-            let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_13, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_17: G = __r_arr[0];
-            let __v_18: G = (__v_15 + __v_17);
-            match __v_18.as_canonical_u64() {
+        let __v_5: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_3.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() {
+          1u64 => {
+            let __v_6: G = G::from_u64(1);
+            let __v_7: G = G::from_u64(0);
+            let __v_8: G = { let __values: [G; 3] = [__v_7, __v_0, __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_274] = [__v_6, __v_8];
+            record.function_queries[274].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          0u64 => {
+            let __v_6: G = { let __a_val = __v_3.as_canonical_u64(); let __b_val = __v_0.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_6.as_canonical_u64() {
               0u64 => {
-                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 = { let __values: [G; 4] = [__v_20, __v_21, __v_22, __v_22]; 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_362] = [__v_19, __v_23];
-                record.function_queries[362].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __v_7: G = G::from_u64(0);
+                let __ret: [G; OUT_274] = [__v_7, __v_1];
+                record.function_queries[274].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
-              _ => {
-                let __v_19: G = G::from_u64(1);
-                let __r_arr: [G; OUT_360] = { let __args: [G; IN_360] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[360].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_360] = unsafe { *(result.output.as_ptr() as *const [G; OUT_360]) }; __ret } else { aiur_fn_360(__args, record, io_buffer, __cu)? } };
-                let __v_20: G = __r_arr[0];
-                let __ret: [G; OUT_362] = [__v_19, __v_20];
-                record.function_queries[362].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+              1u64 => {
+                let __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[274].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_274] = unsafe { *(result.output.as_ptr() as *const [G; OUT_274]) }; __ret } else { aiur_fn_274(__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(0);
+                let __v_10: G = { let __values: [G; 3] = [__v_9, __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_274] = [__v_7, __v_10];
+                record.function_queries[274].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
+              _ => {
+                return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64()));
+              },
             }
           },
           _ => {
-            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; 4] = [__v_14, __v_15, __v_16, __v_16]; 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_362] = [__v_13, __v_17];
-            record.function_queries[362].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
+            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
           },
         }
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_363: usize = 2;
-const IN_363: usize = 2;
-const OUT_363: usize = 2;
-fn aiur_fn_363(
-  inp: [G; IN_363],
+const INPUT_SIZE_275: usize = 3;
+const IN_275: usize = 3;
+const OUT_275: usize = 1;
+fn aiur_fn_275(
+  inp: [G; IN_275],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_363], ExecError> {
+) -> Result<[G; OUT_275], 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() {
-      2u64 => {
-        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-        let __v_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[302].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_302] = unsafe { *(result.output.as_ptr() as *const [G; OUT_302]) }; __ret } else { aiur_fn_302(__args, record, io_buffer, __cu)? } };
-        let __v_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[303].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_303] = unsafe { *(result.output.as_ptr() as *const [G; OUT_303]) }; __ret } else { aiur_fn_303(__args, record, io_buffer, __cu)? } };
-        let __v_9: G = __r_arr[0];
-        let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_10: G = __r_arr[0];
-        let __v_11: G = (__v_8 + __v_10);
-        match __v_11.as_canonical_u64() {
-          0u64 => {
-            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 = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; 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_363] = [__v_12, __v_16];
-            record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
+    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(0);
+        let __v_7: G = { let __values: [G; 2] = [__v_1, __v_2]; let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_8: G = G::from_u64(1);
+        let __v_9: G = G::from_u64(1);
+        let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __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_7, __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 __ret: [G; OUT_275] = [__v_11];
+        record.function_queries[275].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; 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: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_6: G = __loaded[0];
+        let __v_7: G = __loaded[1];
+        match __v_6.as_canonical_u64() {
           _ => {
-            let __v_12: G = G::from_u64(1);
-            let __ret: [G; OUT_363] = [__v_12, __v_0];
-            record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
+            let __v_8: G = { let __a_val = __v_1.as_canonical_u64(); let __b_val = __v_6.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_8.as_canonical_u64() {
+              1u64 => {
+                let __v_9: G = G::from_u64(0);
+                let __v_10: G = { let __values: [G; 2] = [__v_1, __v_2]; let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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_9, __v_10, __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 __ret: [G; OUT_275] = [__v_11];
+                record.function_queries[275].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              0u64 => {
+                let __v_9: G = { let __a_val = __v_6.as_canonical_u64(); let __b_val = __v_1.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_9.as_canonical_u64() {
+                  1u64 => {
+                    let __v_10: G = G::from_u64(0);
+                    let __r_arr: [G; OUT_275] = { let __args: [G; IN_275] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[275].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_275] = unsafe { *(result.output.as_ptr() as *const [G; OUT_275]) }; __ret } else { aiur_fn_275(__args, record, io_buffer, __cu)? } };
+                    let __v_11: G = __r_arr[0];
+                    let __v_12: G = { let __values: [G; 3] = [__v_10, __v_4, __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_275] = [__v_12];
+                    record.function_queries[275].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
+                  },
+                  0u64 => {
+                    let __v_10: G = { let __a_val = __v_7.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_10.as_canonical_u64() {
+                      1u64 => {
+                        let __v_11: G = G::from_u64(0);
+                        let __v_12: G = { let __values: [G; 2] = [__v_6, __v_2]; let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                        let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __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_275] = [__v_13];
+                        record.function_queries[275].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        return Ok(__ret);
+                      },
+                      0u64 => {
+                        let __ret: [G; OUT_275] = [__v_0];
+                        record.function_queries[275].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        return Ok(__ret);
+                      },
+                      _ => {
+                        return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64()));
+                      },
+                    }
+                  },
+                  _ => {
+                    return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64()));
+                  },
+                }
+              },
+              _ => {
+                return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64()));
+              },
+            }
           },
         }
       },
       _ => {
-        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 = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_9]; 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_363] = [__v_6, __v_10];
-        record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
+        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_364: usize = 1;
-const IN_364: usize = 1;
-const OUT_364: usize = 2;
-fn aiur_fn_364(
-  inp: [G; IN_364],
+const INPUT_SIZE_276: usize = 2;
+const IN_276: usize = 2;
+const OUT_276: usize = 1;
+fn aiur_fn_276(
+  inp: [G; IN_276],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_364], ExecError> {
+) -> Result<[G; OUT_276], 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() {
-      7u64 => {
-        match __v_2.as_canonical_u64() {
+    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 __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_5: G = __loaded[0];
+        let __v_6: G = __loaded[1];
+        let __v_7: G = __loaded[2];
+        match __v_5.as_canonical_u64() {
+          1u64 => {
+            let __v_8: G = G::from_u64(1);
+            let __ret: [G; OUT_276] = [__v_8];
+            record.function_queries[276].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
           0u64 => {
-            let __v_5: G = G::from_u64(1);
-            let __ret: [G; OUT_364] = [__v_5, __v_0];
-            record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __v_8: G = G::from_u64(0);
+            let __ret: [G; OUT_276] = [__v_8];
+            record.function_queries[276].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __v_5: G = G::from_u64(0);
-            let __v_6: G = G::from_u64(0);
-            let __v_7: G = G::from_u64(0);
+            return Err(ExecError::MatchNoCase(__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_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_5: G = __loaded[0];
+        let __v_6: G = __loaded[1];
+        let __v_7: G = __loaded[2];
+        match __v_5.as_canonical_u64() {
+          1u64 => {
             let __v_8: G = G::from_u64(0);
-            let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __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_364] = [__v_5, __v_9];
-            record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_276] = [__v_8];
+            record.function_queries[276].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
+          0u64 => {
+            let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; 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: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+            let __v_8: G = __loaded[0];
+            let __v_9: G = __loaded[1];
+            match __v_8.as_canonical_u64() {
+              _ => {
+                let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; 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: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                let __v_10: G = __loaded[0];
+                let __v_11: G = __loaded[1];
+                match __v_10.as_canonical_u64() {
+                  _ => {
+                    let __v_12: G = (__v_8 - __v_10);
+                    match __v_12.as_canonical_u64() {
+                      0u64 => {
+                        let __v_13: G = (__v_9 - __v_11);
+                        match __v_13.as_canonical_u64() {
+                          0u64 => {
+                            let __r_arr: [G; OUT_276] = { let __args: [G; IN_276] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[276].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_276] = unsafe { *(result.output.as_ptr() as *const [G; OUT_276]) }; __ret } else { aiur_fn_276(__args, record, io_buffer, __cu)? } };
+                            let __v_14: G = __r_arr[0];
+                            let __ret: [G; OUT_276] = [__v_14];
+                            record.function_queries[276].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            return Ok(__ret);
+                          },
+                          _ => {
+                            let __v_14: G = G::from_u64(0);
+                            let __ret: [G; OUT_276] = [__v_14];
+                            record.function_queries[276].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            return Ok(__ret);
+                          },
+                        }
+                      },
+                      _ => {
+                        let __v_13: G = G::from_u64(0);
+                        let __ret: [G; OUT_276] = [__v_13];
+                        record.function_queries[276].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        return Ok(__ret);
+                      },
+                    }
+                  },
+                }
+              },
+            }
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
+          },
         }
       },
       _ => {
-        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; 4] = [__v_6, __v_7, __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_364] = [__v_5, __v_9];
-        record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_365: usize = 7;
-const IN_365: usize = 7;
-const OUT_365: usize = 2;
-fn aiur_fn_365(
-  inp: [G; IN_365],
+const INPUT_SIZE_277: usize = 1;
+const IN_277: usize = 1;
+const OUT_277: usize = 1;
+fn aiur_fn_277(
+  inp: [G; IN_277],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_365], ExecError> {
+) -> Result<[G; OUT_277], 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 __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[246].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_246] = unsafe { *(result.output.as_ptr() as *const [G; OUT_246]) }; __ret } else { aiur_fn_246(__args, record, io_buffer, __cu)? } };
-    let __v_7: G = __r_arr[0];
-    let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_8: G = __r_arr[0];
-    let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[247].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_247] = unsafe { *(result.output.as_ptr() as *const [G; OUT_247]) }; __ret } else { aiur_fn_247(__args, record, io_buffer, __cu)? } };
-    let __v_9: G = __r_arr[0];
-    let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_10: G = __r_arr[0];
-    let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[248].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_248] = unsafe { *(result.output.as_ptr() as *const [G; OUT_248]) }; __ret } else { aiur_fn_248(__args, record, io_buffer, __cu)? } };
-    let __v_11: G = __r_arr[0];
-    let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_12: G = __r_arr[0];
-    let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[250].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_250] = unsafe { *(result.output.as_ptr() as *const [G; OUT_250]) }; __ret } else { aiur_fn_250(__args, record, io_buffer, __cu)? } };
-    let __v_13: G = __r_arr[0];
-    let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_14: G = __r_arr[0];
-    let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[249].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_249] = unsafe { *(result.output.as_ptr() as *const [G; OUT_249]) }; __ret } else { aiur_fn_249(__args, record, io_buffer, __cu)? } };
-    let __v_15: G = __r_arr[0];
-    let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_16: G = __r_arr[0];
-    let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } else { aiur_fn_251(__args, record, io_buffer, __cu)? } };
-    let __v_17: G = __r_arr[0];
-    let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_18: G = __r_arr[0];
-    let __v_19: G = (__v_16 + __v_18);
-    let __v_20: G = (__v_14 + __v_19);
-    match __v_20.as_canonical_u64() {
+    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 __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } else { aiur_fn_368(__args, record, io_buffer, __cu)? } };
-        let __v_21: G = __r_arr[0];
-        let __v_22: G = __r_arr[1];
-        let __ret: [G; OUT_365] = [__v_21, __v_22];
-        record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __v_4: G = G::from_u64(0);
+        let __ret: [G; OUT_277] = [__v_4];
+        record.function_queries[277].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      _ => {
-        let __v_21: G = (__v_10 + __v_12);
-        let __v_22: G = (__v_8 + __v_21);
-        match __v_22.as_canonical_u64() {
-          0u64 => {
-            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 __v_26: G = G::from_u64(0);
-            let __v_27: G = { let __values: [G; 4] = [__v_24, __v_25, __v_26, __v_26]; 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_365] = [__v_23, __v_27];
-            record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
+      0u64 => {
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; 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: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_4: G = __loaded[0];
+        let __v_5: G = __loaded[1];
+        match __v_4.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { 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_23: G = __r_arr[0];
-            let __v_24: G = G::from_u64(2);
-            let __v_25: G = { let __a_val = __v_23.as_canonical_u64(); let __b_val = __v_24.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_25.as_canonical_u64() {
+            let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[277].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_277] = unsafe { *(result.output.as_ptr() as *const [G; OUT_277]) }; __ret } else { aiur_fn_277(__args, record, io_buffer, __cu)? } };
+            let __v_6: G = __r_arr[0];
+            let __v_7: G = { let __a_val = __v_6.as_canonical_u64(); let __b_val = __v_5.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_7.as_canonical_u64() {
               1u64 => {
-                let __v_26: G = G::from_u64(0);
-                let __v_27: G = G::from_u64(0);
-                let __v_28: G = G::from_u64(0);
-                let __v_29: G = G::from_u64(0);
-                let __v_30: G = { let __values: [G; 4] = [__v_27, __v_28, __v_29, __v_29]; 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_365] = [__v_26, __v_30];
-                record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_277] = [__v_5];
+                record.function_queries[277].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               0u64 => {
-                let __r_arr: [G; OUT_370] = { let __args: [G; IN_370] = [__v_8, __v_10, __v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[370].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_370] = unsafe { *(result.output.as_ptr() as *const [G; OUT_370]) }; __ret } else { aiur_fn_370(__args, record, io_buffer, __cu)? } };
-                let __v_26: G = __r_arr[0];
-                let __v_27: G = __r_arr[1];
-                let __ret: [G; OUT_365] = [__v_26, __v_27];
-                record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_277] = [__v_6];
+                record.function_queries[277].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                return Err(ExecError::MatchNoCase(__v_25.as_canonical_u64()));
+                return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64()));
               },
             }
           },
         }
       },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+      },
     }
   })
 }
 
-const INPUT_SIZE_366: usize = 2;
-const IN_366: usize = 2;
-const OUT_366: usize = 3;
-fn aiur_fn_366(
-  inp: [G; IN_366],
+const INPUT_SIZE_278: usize = 2;
+const IN_278: usize = 2;
+const OUT_278: usize = 1;
+fn aiur_fn_278(
+  inp: [G; IN_278],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_366], ExecError> {
+) -> Result<[G; OUT_278], 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 __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];
-    let __v_5: G = __loaded[3];
     match __v_2.as_canonical_u64() {
-      3u64 => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; 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: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].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];
-        match __v_6.as_canonical_u64() {
-          2u64 => {
-            let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_1, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-            let __v_10: G = __r_arr[0];
-            let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } else { aiur_fn_252(__args, record, io_buffer, __cu)? } };
-            let __v_11: G = __r_arr[0];
-            let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_12: G = __r_arr[0];
-            let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[253].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_253] = unsafe { *(result.output.as_ptr() as *const [G; OUT_253]) }; __ret } else { aiur_fn_253(__args, record, io_buffer, __cu)? } };
-            let __v_13: G = __r_arr[0];
-            let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_10, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_14: G = __r_arr[0];
-            let __v_15: G = (__v_12 + __v_14);
-            match __v_15.as_canonical_u64() {
-              0u64 => {
-                let __v_16: G = G::from_u64(0);
-                let __v_17: G = G::from_u64(0);
-                let __v_18: G = G::from_u64(1);
-                let __v_19: G = G::from_u64(1);
-                let __v_20: G = { let __values: [G; 10] = [__v_18, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19]; 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_366] = [__v_16, __v_17, __v_20];
-                record.function_queries[366].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
+      1u64 => {
+        let __ret: [G; OUT_278] = [__v_0];
+        record.function_queries[278].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_5: G = __loaded[0];
+        let __v_6: G = __loaded[1];
+        let __v_7: G = __loaded[2];
+        match __v_5.as_canonical_u64() {
+          1u64 => {
+            let __ret: [G; OUT_278] = [__v_0];
+            record.function_queries[278].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          0u64 => {
+            let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; 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: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+            let __v_8: G = __loaded[0];
+            let __v_9: G = __loaded[1];
+            match __v_8.as_canonical_u64() {
               _ => {
-                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_16: G = __loaded[0];
-                let __v_17: G = __loaded[1];
-                let __v_18: G = __loaded[2];
-                let __v_19: G = __loaded[3];
-                match __v_16.as_canonical_u64() {
-                  7u64 => {
-                    match __v_17.as_canonical_u64() {
-                      0u64 => {
-                        let __v_20: G = G::from_u64(1);
-                        let __ret: [G; OUT_366] = [__v_20, __v_14, __v_18];
-                        record.function_queries[366].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; 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: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                let __v_10: G = __loaded[0];
+                let __v_11: G = __loaded[1];
+                match __v_10.as_canonical_u64() {
+                  _ => {
+                    let __v_12: G = { let __a_val = __v_8.as_canonical_u64(); let __b_val = __v_10.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_12.as_canonical_u64() {
+                      1u64 => {
+                        let __v_13: G = G::from_u64(0);
+                        let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } else { aiur_fn_278(__args, record, io_buffer, __cu)? } };
+                        let __v_14: G = __r_arr[0];
+                        let __v_15: G = { let __values: [G; 3] = [__v_13, __v_3, __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_278] = [__v_15];
+                        record.function_queries[278].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
+                      0u64 => {
+                        let __v_13: G = { let __a_val = __v_10.as_canonical_u64(); let __b_val = __v_8.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_13.as_canonical_u64() {
+                          1u64 => {
+                            let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } else { aiur_fn_278(__args, record, io_buffer, __cu)? } };
+                            let __v_14: G = __r_arr[0];
+                            let __ret: [G; OUT_278] = [__v_14];
+                            record.function_queries[278].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            return Ok(__ret);
+                          },
+                          0u64 => {
+                            let __v_14: G = { let __a_val = __v_11.as_canonical_u64(); let __b_val = __v_9.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_14.as_canonical_u64() {
+                              1u64 => {
+                                let __v_15: G = G::from_u64(0);
+                                let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } else { aiur_fn_278(__args, record, io_buffer, __cu)? } };
+                                let __v_16: G = __r_arr[0];
+                                let __v_17: G = { let __values: [G; 3] = [__v_15, __v_3, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_278] = [__v_17];
+                                record.function_queries[278].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                return Ok(__ret);
+                              },
+                              0u64 => {
+                                let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } else { aiur_fn_278(__args, record, io_buffer, __cu)? } };
+                                let __v_15: G = __r_arr[0];
+                                let __ret: [G; OUT_278] = [__v_15];
+                                record.function_queries[278].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                return Ok(__ret);
+                              },
+                              _ => {
+                                return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64()));
+                              },
+                            }
+                          },
+                          _ => {
+                            return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64()));
+                          },
+                        }
+                      },
                       _ => {
-                        let __v_20: G = G::from_u64(0);
-                        let __v_21: G = G::from_u64(0);
-                        let __v_22: G = G::from_u64(1);
-                        let __v_23: G = G::from_u64(1);
-                        let __v_24: G = { let __values: [G; 10] = [__v_22, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; 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_366] = [__v_20, __v_21, __v_24];
-                        record.function_queries[366].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                        return Ok(__ret);
+                        return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64()));
                       },
                     }
                   },
-                  _ => {
-                    let __v_20: G = G::from_u64(0);
-                    let __v_21: G = G::from_u64(0);
-                    let __v_22: G = G::from_u64(1);
-                    let __v_23: G = G::from_u64(1);
-                    let __v_24: G = { let __values: [G; 10] = [__v_22, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; 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_366] = [__v_20, __v_21, __v_24];
-                    record.function_queries[366].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
                 }
               },
             }
           },
           _ => {
-            let __v_10: G = G::from_u64(0);
-            let __v_11: G = G::from_u64(0);
-            let __v_12: G = G::from_u64(1);
-            let __v_13: G = G::from_u64(1);
-            let __v_14: G = { let __values: [G; 10] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __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_366] = [__v_10, __v_11, __v_14];
-            record.function_queries[366].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
+            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
           },
         }
       },
       _ => {
-        let __v_6: G = G::from_u64(0);
-        let __v_7: G = G::from_u64(0);
-        let __v_8: G = G::from_u64(1);
-        let __v_9: G = G::from_u64(1);
-        let __v_10: G = { let __values: [G; 10] = [__v_8, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9]; 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_366] = [__v_6, __v_7, __v_10];
-        record.function_queries[366].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_367: usize = 3;
-const IN_367: usize = 3;
-const OUT_367: usize = 2;
-fn aiur_fn_367(
-  inp: [G; IN_367],
+const INPUT_SIZE_279: usize = 3;
+const IN_279: usize = 3;
+const OUT_279: usize = 1;
+fn aiur_fn_279(
+  inp: [G; IN_279],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_367], ExecError> {
+) -> Result<[G; OUT_279], 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 __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_0.as_canonical_u64() {
-  0u64 => {
-    let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } else { aiur_fn_252(__args, record, io_buffer, __cu)? } };
-    let __v_3: G = __r_arr[0];
-    break '__mc_0 [__v_3];
-  },
-  _ => {
-    let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[253].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_253] = unsafe { *(result.output.as_ptr() as *const [G; OUT_253]) }; __ret } else { aiur_fn_253(__args, record, io_buffer, __cu)? } };
-    let __v_3: G = __r_arr[0];
-    break '__mc_0 [__v_3];
-  },
-}
- };
-    let __v_3: G = __mc_out___mc_0[0];
-    let __v_4: G = G::from_u64(0);
-    let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_3, __v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } else { aiur_fn_334(__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() {
-      1u64 => {
-        let __v_7: G = G::from_u64(2);
-        let __v_8: G = G::from_u64(1);
-        let __v_9: G = G::from_u64(1);
-        let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __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 = G::from_u64(0);
-        let __v_12: G = { let __values: [G; 4] = [__v_7, __v_6, __v_10, __v_11]; 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_13: G = G::from_u64(1);
-        let __v_14: G = G::from_u64(3);
-        let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } else { aiur_fn_338(__args, record, io_buffer, __cu)? } };
-        let __v_15: G = __r_arr[0];
-        let __v_16: G = G::from_u64(0);
-        let __v_17: G = { let __values: [G; 4] = [__v_14, __v_12, __v_15, __v_16]; 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_367] = [__v_13, __v_17];
-        record.function_queries[367].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
+    match __v_2.as_canonical_u64() {
       0u64 => {
-        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 = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __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_367] = [__v_7, __v_11];
-        record.function_queries[367].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_279] = [__v_0];
+        record.function_queries[279].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_3: G = __loaded[0];
+        let __v_4: G = __loaded[1];
+        let __v_5: G = __loaded[2];
+        match __v_3.as_canonical_u64() {
+          1u64 => {
+            let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[280].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_280] = unsafe { *(result.output.as_ptr() as *const [G; OUT_280]) }; __ret } else { aiur_fn_280(__args, record, io_buffer, __cu)? } };
+            let __v_6: G = __r_arr[0];
+            let __ret: [G; OUT_279] = [__v_6];
+            record.function_queries[279].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          0u64 => {
+            let __ret: [G; OUT_279] = [__v_0];
+            record.function_queries[279].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
+          },
+        }
+      },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
+        let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[280].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_280] = unsafe { *(result.output.as_ptr() as *const [G; OUT_280]) }; __ret } else { aiur_fn_280(__args, record, io_buffer, __cu)? } };
+        let __v_3: G = __r_arr[0];
+        let __ret: [G; OUT_279] = [__v_3];
+        record.function_queries[279].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_368: usize = 6;
-const IN_368: usize = 6;
-const OUT_368: usize = 2;
-fn aiur_fn_368(
-  inp: [G; IN_368],
+const INPUT_SIZE_280: usize = 3;
+const IN_280: usize = 3;
+const OUT_280: usize = 1;
+fn aiur_fn_280(
+  inp: [G; IN_280],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_368], ExecError> {
+) -> Result<[G; OUT_280], 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_187] = { let __args: [G; IN_187] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { 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_6: G = __r_arr[0];
-    let __v_7: G = G::from_u64(2);
-    let __v_8: G = { let __a_val = __v_6.as_canonical_u64(); let __b_val = __v_7.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_8.as_canonical_u64() {
+    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_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 = { let __values: [G; 4] = [__v_10, __v_11, __v_12, __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_368] = [__v_9, __v_13];
-        record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __v_6: G = G::from_u64(0);
+        let __v_7: G = G::from_u64(1);
+        let __v_8: G = G::from_u64(1);
+        let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __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_10: G = { let __values: [G; 3] = [__v_1, __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 = 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 __v_14: G = { let __values: [G; 3] = [__v_6, __v_10, __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 __ret: [G; OUT_280] = [__v_14];
+        record.function_queries[280].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __v_9: G = G::from_u64(0);
-        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-        let __v_10: G = __r_arr[0];
-        let __v_11: G = G::from_u64(1);
-        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_2, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-        let __v_12: G = __r_arr[0];
-        let __r_arr: [G; OUT_366] = { let __args: [G; IN_366] = [__v_10, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[366].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_366] = unsafe { *(result.output.as_ptr() as *const [G; OUT_366]) }; __ret } else { aiur_fn_366(__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];
-        match __v_13.as_canonical_u64() {
-          1u64 => {
-            let __r_arr: [G; OUT_366] = { let __args: [G; IN_366] = [__v_12, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[366].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_366] = unsafe { *(result.output.as_ptr() as *const [G; OUT_366]) }; __ret } else { aiur_fn_366(__args, record, io_buffer, __cu)? } };
-            let __v_16: G = __r_arr[0];
-            let __v_17: G = __r_arr[1];
-            let __v_18: G = __r_arr[2];
-            match __v_16.as_canonical_u64() {
+        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_6: G = __loaded[0];
+        let __v_7: G = __loaded[1];
+        let __v_8: G = __loaded[2];
+        match __v_6.as_canonical_u64() {
+          _ => {
+            let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[271].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_271] = unsafe { *(result.output.as_ptr() as *const [G; OUT_271]) }; __ret } else { aiur_fn_271(__args, record, io_buffer, __cu)? } };
+            let __v_9: G = __r_arr[0];
+            match __v_9.as_canonical_u64() {
+              0u64 => {
+                let __v_10: G = { let __a_val = __v_7.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_10.as_canonical_u64() {
+                  1u64 => {
+                    let __v_11: G = G::from_u64(0);
+                    let __v_12: G = { let __values: [G; 3] = [__v_6, __v_2, __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_13: G = { let __values: [G; 3] = [__v_11, __v_12, __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_280] = [__v_13];
+                    record.function_queries[280].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
+                  },
+                  0u64 => {
+                    let __ret: [G; OUT_280] = [__v_0];
+                    record.function_queries[280].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
+                  },
+                  _ => {
+                    return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64()));
+                  },
+                }
+              },
               1u64 => {
-                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 = { let __values: [G; 4] = [__v_20, __v_21, __v_22, __v_22]; 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_368] = [__v_19, __v_23];
-                record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                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 = { 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 __v_14: G = { let __values: [G; 3] = [__v_1, __v_2, __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_15: G = { let __values: [G; 3] = [__v_10, __v_14, __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 __ret: [G; OUT_280] = [__v_15];
+                record.function_queries[280].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__v_0, __v_1, __v_2, __v_10, __v_12, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[369].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_369] = unsafe { *(result.output.as_ptr() as *const [G; OUT_369]) }; __ret } else { aiur_fn_369(__args, record, io_buffer, __cu)? } };
-                let __v_19: G = __r_arr[0];
-                let __v_20: G = __r_arr[1];
-                let __ret: [G; OUT_368] = [__v_19, __v_20];
-                record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __v_10: G = G::from_u64(0);
+                let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[280].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_280] = unsafe { *(result.output.as_ptr() as *const [G; OUT_280]) }; __ret } else { aiur_fn_280(__args, record, io_buffer, __cu)? } };
+                let __v_11: G = __r_arr[0];
+                let __v_12: G = { let __values: [G; 3] = [__v_10, __v_4, __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_280] = [__v_12];
+                record.function_queries[280].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
-          _ => {
-            let __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__v_0, __v_1, __v_2, __v_10, __v_12, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[369].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_369] = unsafe { *(result.output.as_ptr() as *const [G; OUT_369]) }; __ret } else { aiur_fn_369(__args, record, io_buffer, __cu)? } };
-            let __v_16: G = __r_arr[0];
-            let __v_17: G = __r_arr[1];
-            let __ret: [G; OUT_368] = [__v_16, __v_17];
-            record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
         }
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64()));
+        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_369: usize = 8;
-const IN_369: usize = 8;
-const OUT_369: usize = 2;
-fn aiur_fn_369(
-  inp: [G; IN_369],
+const INPUT_SIZE_281: usize = 4;
+const IN_281: usize = 4;
+const OUT_281: usize = 1;
+fn aiur_fn_281(
+  inp: [G; IN_281],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_369], ExecError> {
+) -> Result<[G; OUT_281], 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 __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_3, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } };
-    let __v_8: G = __r_arr[0];
-    let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } };
-    let __v_9: G = __r_arr[0];
-    let __r_arr: [G; OUT_366] = { let __args: [G; IN_366] = [__v_8, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[366].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_366] = unsafe { *(result.output.as_ptr() as *const [G; OUT_366]) }; __ret } else { aiur_fn_366(__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];
-    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_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_4: G = __loaded[0];
+    let __v_5: G = __loaded[1];
+    let __v_6: G = __loaded[2];
+    match __v_4.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_366] = { let __args: [G; IN_366] = [__v_9, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[366].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_366] = unsafe { *(result.output.as_ptr() as *const [G; OUT_366]) }; __ret } else { aiur_fn_366(__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];
-        match __v_13.as_canonical_u64() {
-          1u64 => {
-            let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_11, __v_12, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[367].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_367] = unsafe { *(result.output.as_ptr() as *const [G; OUT_367]) }; __ret } else { aiur_fn_367(__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_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 = { let __values: [G; 2] = [__v_2, __v_3]; let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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 = 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 __v_14: G = { let __values: [G; 3] = [__v_9, __v_10, __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_15: G = { let __values: [G; 3] = [__v_1, __v_8, __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 __v_16: G = G::from_u64(1);
+        let __v_17: G = G::from_u64(1);
+        let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __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_7, __v_15, __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 __ret: [G; OUT_281] = [__v_19];
+        record.function_queries[281].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_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_7: G = __loaded[0];
+        let __v_8: G = __loaded[1];
+        let __v_9: G = __loaded[2];
+        match __v_7.as_canonical_u64() {
+          _ => {
+            let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = [__v_1, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[271].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_271] = unsafe { *(result.output.as_ptr() as *const [G; OUT_271]) }; __ret } else { aiur_fn_271(__args, record, io_buffer, __cu)? } };
+            let __v_10: G = __r_arr[0];
+            match __v_10.as_canonical_u64() {
+              0u64 => {
+                let __v_11: G = G::from_u64(0);
+                let __r_arr: [G; OUT_275] = { let __args: [G; IN_275] = [__v_9, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[275].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_275] = unsafe { *(result.output.as_ptr() as *const [G; OUT_275]) }; __ret } else { aiur_fn_275(__args, record, io_buffer, __cu)? } };
+                let __v_12: G = __r_arr[0];
+                let __v_13: G = { let __values: [G; 3] = [__v_7, __v_8, __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 __v_14: G = { let __values: [G; 3] = [__v_11, __v_13, __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_281] = [__v_14];
+                record.function_queries[281].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
               1u64 => {
-                let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_14, __v_15, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[367].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_367] = unsafe { *(result.output.as_ptr() as *const [G; OUT_367]) }; __ret } else { aiur_fn_367(__args, record, io_buffer, __cu)? } };
-                let __v_18: G = __r_arr[0];
-                let __v_19: G = __r_arr[1];
-                match __v_18.as_canonical_u64() {
-                  1u64 => {
-                    let __v_20: G = G::from_u64(2);
-                    let __v_21: G = G::from_u64(0);
-                    let __v_22: G = { let __values: [G; 4] = [__v_20, __v_0, __v_1, __v_21]; 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_23: G = G::from_u64(3);
-                    let __v_24: G = G::from_u64(0);
-                    let __v_25: G = { let __values: [G; 4] = [__v_23, __v_22, __v_17, __v_24]; 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_26: G = G::from_u64(3);
-                    let __v_27: G = G::from_u64(0);
-                    let __v_28: G = { let __values: [G; 4] = [__v_26, __v_25, __v_19, __v_27]; 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_29: G = G::from_u64(2);
-                    let __r_arr: [G; OUT_796] = { let __args: [G; IN_796] = [__v_2, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[796].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_796] = unsafe { *(result.output.as_ptr() as *const [G; OUT_796]) }; __ret } else { aiur_fn_796(__args, record, io_buffer, __cu)? } };
-                    let __v_30: G = __r_arr[0];
-                    let __v_31: G = G::from_u64(1);
-                    let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_28, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[427].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_427] = unsafe { *(result.output.as_ptr() as *const [G; OUT_427]) }; __ret } else { aiur_fn_427(__args, record, io_buffer, __cu)? } };
-                    let __v_32: G = __r_arr[0];
-                    let __ret: [G; OUT_369] = [__v_31, __v_32];
-                    record.function_queries[369].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
-                  _ => {
-                    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 __v_24: G = { let __values: [G; 4] = [__v_21, __v_22, __v_23, __v_23]; 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_369] = [__v_20, __v_24];
-                    record.function_queries[369].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
-                }
+                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 = { let __values: [G; 2] = [__v_2, __v_3]; let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_15: G = G::from_u64(1);
+                let __v_16: G = G::from_u64(1);
+                let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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_13, __v_14, __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_1, __v_12, __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_11, __v_19, __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 __ret: [G; OUT_281] = [__v_20];
+                record.function_queries[281].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
               },
               _ => {
-                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 = { let __values: [G; 4] = [__v_19, __v_20, __v_21, __v_21]; 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_369] = [__v_18, __v_22];
-                record.function_queries[369].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __v_11: G = G::from_u64(0);
+                let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[281].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_281] = unsafe { *(result.output.as_ptr() as *const [G; OUT_281]) }; __ret } else { aiur_fn_281(__args, record, io_buffer, __cu)? } };
+                let __v_12: G = __r_arr[0];
+                let __v_13: G = { let __values: [G; 3] = [__v_11, __v_5, __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 __ret: [G; OUT_281] = [__v_13];
+                record.function_queries[281].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
-          _ => {
-            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 = { let __values: [G; 4] = [__v_17, __v_18, __v_19, __v_19]; 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_369] = [__v_16, __v_20];
-            record.function_queries[369].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
         }
       },
       _ => {
-        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; 4] = [__v_14, __v_15, __v_16, __v_16]; 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_369] = [__v_13, __v_17];
-        record.function_queries[369].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
+        return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_370: usize = 9;
-const IN_370: usize = 9;
-const OUT_370: usize = 2;
-fn aiur_fn_370(
-  inp: [G; IN_370],
+const INPUT_SIZE_282: usize = 4;
+const IN_282: usize = 4;
+const OUT_282: usize = 1;
+fn aiur_fn_282(
+  inp: [G; IN_282],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_370], ExecError> {
+) -> Result<[G; OUT_282], 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];
-    match __v_2.as_canonical_u64() {
+    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_4: G = __loaded[0];
+    let __v_5: G = __loaded[1];
+    let __v_6: G = __loaded[2];
+    match __v_4.as_canonical_u64() {
+      0u64 => {
+        let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_3, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } else { aiur_fn_279(__args, record, io_buffer, __cu)? } };
+        let __v_7: G = __r_arr[0];
+        let __ret: [G; OUT_282] = [__v_7];
+        record.function_queries[282].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
       1u64 => {
-        let __v_9: G = G::from_u64(0);
-        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-        let __v_10: G = __r_arr[0];
-        let __v_11: G = G::from_u64(1);
-        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_5, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-        let __v_12: G = __r_arr[0];
-        let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_10, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } };
-        let __v_13: G = __r_arr[0];
-        let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_13, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } else { aiur_fn_336(__args, record, io_buffer, __cu)? } };
-        let __v_14: G = __r_arr[0];
-        let __v_15: G = __r_arr[1];
-        match __v_14.as_canonical_u64() {
-          0u64 => {
-            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 = { let __values: [G; 4] = [__v_17, __v_18, __v_19, __v_19]; 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_370] = [__v_16, __v_20];
-            record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __v_7: G = G::from_u64(1);
+        let __v_8: G = (__v_2 + __v_7);
+        let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_5, __v_1, __v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } else { aiur_fn_282(__args, record, io_buffer, __cu)? } };
+        let __v_9: G = __r_arr[0];
+        let __ret: [G; OUT_282] = [__v_9];
+        record.function_queries[282].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      2u64 => {
+        let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } else { aiur_fn_282(__args, record, io_buffer, __cu)? } };
+        let __v_7: G = __r_arr[0];
+        let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_6, __v_1, __v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } else { aiur_fn_282(__args, record, io_buffer, __cu)? } };
+        let __v_8: G = __r_arr[0];
+        let __ret: [G; OUT_282] = [__v_8];
+        record.function_queries[282].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      3u64 => {
+        let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_5, __v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } else { aiur_fn_283(__args, record, io_buffer, __cu)? } };
+        let __v_7: G = __r_arr[0];
+        let __ret: [G; OUT_282] = [__v_7];
+        record.function_queries[282].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      4u64 => {
+        let __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[274].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_274] = unsafe { *(result.output.as_ptr() as *const [G; OUT_274]) }; __ret } else { aiur_fn_274(__args, record, io_buffer, __cu)? } };
+        let __v_7: G = __r_arr[0];
+        let __v_8: G = __r_arr[1];
+        match __v_7.as_canonical_u64() {
+          1u64 => {
+            let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_3, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } else { aiur_fn_279(__args, record, io_buffer, __cu)? } };
+            let __v_9: G = __r_arr[0];
+            let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = [__v_9, __v_8, __v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[281].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_281] = unsafe { *(result.output.as_ptr() as *const [G; OUT_281]) }; __ret } else { aiur_fn_281(__args, record, io_buffer, __cu)? } };
+            let __v_10: G = __r_arr[0];
+            let __ret: [G; OUT_282] = [__v_10];
+            record.function_queries[282].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
-          1u64 => {
-            let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[304].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_304] = unsafe { *(result.output.as_ptr() as *const [G; OUT_304]) }; __ret } else { aiur_fn_304(__args, record, io_buffer, __cu)? } };
-            let __v_16: G = __r_arr[0];
-            let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } else { aiur_fn_338(__args, record, io_buffer, __cu)? } };
-            let __v_17: G = __r_arr[0];
-            let __v_18: G = G::from_u64(2);
-            let __v_19: G = G::from_u64(0);
-            let __v_20: G = G::from_u64(1);
-            let __v_21: G = G::from_u64(1);
-            let __v_22: G = { let __values: [G; 3] = [__v_20, __v_21, __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 = G::from_u64(0);
-            let __v_24: G = { let __values: [G; 4] = [__v_18, __v_19, __v_22, __v_23]; 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_246] = { let __args: [G; IN_246] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[246].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_246] = unsafe { *(result.output.as_ptr() as *const [G; OUT_246]) }; __ret } else { aiur_fn_246(__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_334] = { let __args: [G; IN_334] = [__v_25, __v_8, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } else { aiur_fn_334(__args, record, io_buffer, __cu)? } };
-            let __v_27: G = __r_arr[0];
-            let __v_28: G = __r_arr[1];
-            match __v_27.as_canonical_u64() {
+          0u64 => {
+            match __v_2.as_canonical_u64() {
               0u64 => {
-                let __v_29: G = G::from_u64(0);
-                let __v_30: G = G::from_u64(0);
-                let __v_31: G = G::from_u64(0);
-                let __v_32: G = G::from_u64(0);
-                let __v_33: G = { let __values: [G; 4] = [__v_30, __v_31, __v_32, __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 __ret: [G; OUT_370] = [__v_29, __v_33];
-                record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              1u64 => {
-                let __v_29: G = G::from_u64(2);
-                let __v_30: G = G::from_u64(1);
-                let __v_31: G = G::from_u64(1);
-                let __v_32: G = { let __values: [G; 3] = [__v_30, __v_31, __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 = G::from_u64(0);
-                let __v_34: G = { let __values: [G; 4] = [__v_29, __v_28, __v_32, __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 __v_35: G = G::from_u64(3);
-                let __v_36: G = G::from_u64(0);
-                let __v_37: G = { let __values: [G; 4] = [__v_35, __v_34, __v_17, __v_36]; 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_38: G = G::from_u64(3);
-                let __v_39: G = G::from_u64(0);
-                let __v_40: G = { let __values: [G; 4] = [__v_38, __v_37, __v_12, __v_39]; 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_41: G = G::from_u64(2);
-                let __r_arr: [G; OUT_796] = { let __args: [G; IN_796] = [__v_5, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[796].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_796] = unsafe { *(result.output.as_ptr() as *const [G; OUT_796]) }; __ret } else { aiur_fn_796(__args, record, io_buffer, __cu)? } };
-                let __v_42: G = __r_arr[0];
-                let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_40, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[427].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_427] = unsafe { *(result.output.as_ptr() as *const [G; OUT_427]) }; __ret } else { aiur_fn_427(__args, record, io_buffer, __cu)? } };
-                let __v_43: G = __r_arr[0];
-                let __v_44: G = G::from_u64(1);
-                let __ret: [G; OUT_370] = [__v_44, __v_43];
-                record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_282] = [__v_3];
+                record.function_queries[282].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                return Err(ExecError::MatchNoCase(__v_27.as_canonical_u64()));
+                let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = [__v_3, __v_1, __v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[281].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_281] = unsafe { *(result.output.as_ptr() as *const [G; OUT_281]) }; __ret } else { aiur_fn_281(__args, record, io_buffer, __cu)? } };
+                let __v_9: G = __r_arr[0];
+                let __ret: [G; OUT_282] = [__v_9];
+                record.function_queries[282].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
               },
             }
           },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64()));
+            return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64()));
           },
         }
       },
-      0u64 => {
-        let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_0, __v_1, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[371].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_371] = unsafe { *(result.output.as_ptr() as *const [G; OUT_371]) }; __ret } else { aiur_fn_371(__args, record, io_buffer, __cu)? } };
-        let __v_9: G = __r_arr[0];
-        let __v_10: G = __r_arr[1];
-        let __ret: [G; OUT_370] = [__v_9, __v_10];
-        record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+        return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_371: usize = 8;
-const IN_371: usize = 8;
-const OUT_371: usize = 2;
-fn aiur_fn_371(
-  inp: [G; IN_371],
+const INPUT_SIZE_283: usize = 5;
+const IN_283: usize = 5;
+const OUT_283: usize = 1;
+fn aiur_fn_283(
+  inp: [G; IN_283],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_371], ExecError> {
+) -> Result<[G; OUT_283], 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(0);
-    let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-    let __v_9: G = __r_arr[0];
-    let __v_10: G = G::from_u64(1);
-    let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_4, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-    let __v_11: G = __r_arr[0];
-    let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_9, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } };
-    let __v_12: G = __r_arr[0];
-    let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_11, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } };
-    let __v_13: G = __r_arr[0];
-    let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_12, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } else { aiur_fn_336(__args, record, io_buffer, __cu)? } };
-    let __v_14: G = __r_arr[0];
-    let __v_15: G = __r_arr[1];
-    let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_13, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } else { aiur_fn_336(__args, record, io_buffer, __cu)? } };
-    let __v_16: G = __r_arr[0];
-    let __v_17: G = __r_arr[1];
-    match __v_14.as_canonical_u64() {
+    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_5: G = __loaded[0];
+    let __v_6: G = __loaded[1];
+    let __v_7: G = __loaded[2];
+    match __v_5.as_canonical_u64() {
       0u64 => {
-        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 = { let __values: [G; 4] = [__v_19, __v_20, __v_21, __v_21]; 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_371] = [__v_18, __v_22];
-        record.function_queries[371].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_4, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } else { aiur_fn_279(__args, record, io_buffer, __cu)? } };
+        let __v_8: G = __r_arr[0];
+        let __ret: [G; OUT_283] = [__v_8];
+        record.function_queries[283].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
-        match __v_16.as_canonical_u64() {
-          0u64 => {
-            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 = { let __values: [G; 4] = [__v_19, __v_20, __v_21, __v_21]; 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_371] = [__v_18, __v_22];
-            record.function_queries[371].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __v_8: G = G::from_u64(1);
+        let __v_9: G = (__v_3 + __v_8);
+        let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } else { aiur_fn_282(__args, record, io_buffer, __cu)? } };
+        let __v_10: G = __r_arr[0];
+        let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_6, __v_2, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } else { aiur_fn_282(__args, record, io_buffer, __cu)? } };
+        let __v_11: G = __r_arr[0];
+        let __ret: [G; OUT_283] = [__v_11];
+        record.function_queries[283].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      2u64 => {
+        let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_0, __v_6, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } else { aiur_fn_283(__args, record, io_buffer, __cu)? } };
+        let __v_8: G = __r_arr[0];
+        let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_0, __v_7, __v_2, __v_3, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } else { aiur_fn_283(__args, record, io_buffer, __cu)? } };
+        let __v_9: G = __r_arr[0];
+        let __ret: [G; OUT_283] = [__v_9];
+        record.function_queries[283].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      3u64 => {
+        let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_0, __v_7, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } else { aiur_fn_283(__args, record, io_buffer, __cu)? } };
+        let __v_8: G = __r_arr[0];
+        let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_6, __v_7, __v_2, __v_3, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } else { aiur_fn_283(__args, record, io_buffer, __cu)? } };
+        let __v_9: G = __r_arr[0];
+        let __ret: [G; OUT_283] = [__v_9];
+        record.function_queries[283].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      4u64 => {
+        let __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = [__v_6, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[274].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_274] = unsafe { *(result.output.as_ptr() as *const [G; OUT_274]) }; __ret } else { aiur_fn_274(__args, record, io_buffer, __cu)? } };
+        let __v_8: G = __r_arr[0];
+        let __v_9: G = __r_arr[1];
+        match __v_8.as_canonical_u64() {
+          1u64 => {
+            let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_4, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } else { aiur_fn_279(__args, record, io_buffer, __cu)? } };
+            let __v_10: G = __r_arr[0];
+            let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = [__v_10, __v_9, __v_6, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[281].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_281] = unsafe { *(result.output.as_ptr() as *const [G; OUT_281]) }; __ret } else { aiur_fn_281(__args, record, io_buffer, __cu)? } };
+            let __v_11: G = __r_arr[0];
+            let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0, __v_9, __v_3, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } else { aiur_fn_282(__args, record, io_buffer, __cu)? } };
+            let __v_12: G = __r_arr[0];
+            let __ret: [G; OUT_283] = [__v_12];
+            record.function_queries[283].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
-          1u64 => {
-            let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_0.as_canonical_u64() {
-  1u64 => {
-    let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_15, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[311].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_311] = unsafe { *(result.output.as_ptr() as *const [G; OUT_311]) }; __ret } else { aiur_fn_311(__args, record, io_buffer, __cu)? } };
-    let __v_18: G = __r_arr[0];
-    break '__mc_0 [__v_18];
-  },
+          0u64 => {
+            let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_3.as_canonical_u64() {
   0u64 => {
-    let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_15, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_230] = unsafe { *(result.output.as_ptr() as *const [G; OUT_230]) }; __ret } else { aiur_fn_230(__args, record, io_buffer, __cu)? } };
-    let __v_18: G = __r_arr[0];
-    break '__mc_0 [__v_18];
+    break '__mc_0 [__v_4];
   },
   _ => {
-    return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64()));
+    let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = [__v_4, __v_2, __v_6, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[281].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_281] = unsafe { *(result.output.as_ptr() as *const [G; OUT_281]) }; __ret } else { aiur_fn_281(__args, record, io_buffer, __cu)? } };
+    let __v_10: G = __r_arr[0];
+    break '__mc_0 [__v_10];
   },
 }
  };
-            let __v_18: G = __mc_out___mc_0[0];
-            let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_0, __v_1, __v_18, __v_9, __v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[372].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_372] = unsafe { *(result.output.as_ptr() as *const [G; OUT_372]) }; __ret } else { aiur_fn_372(__args, record, io_buffer, __cu)? } };
-            let __v_19: G = __r_arr[0];
-            let __v_20: G = __r_arr[1];
-            let __ret: [G; OUT_371] = [__v_19, __v_20];
-            record.function_queries[371].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __v_10: G = __mc_out___mc_0[0];
+            let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0, __v_2, __v_3, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } else { aiur_fn_282(__args, record, io_buffer, __cu)? } };
+            let __v_11: G = __r_arr[0];
+            let __ret: [G; OUT_283] = [__v_11];
+            record.function_queries[283].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_16.as_canonical_u64()));
+            return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64()));
           },
         }
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64()));
+        return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_372: usize = 11;
-const IN_372: usize = 11;
-const OUT_372: usize = 2;
-fn aiur_fn_372(
-  inp: [G; IN_372],
+const INPUT_SIZE_284: usize = 2;
+const IN_284: usize = 2;
+const OUT_284: usize = 1;
+fn aiur_fn_284(
+  inp: [G; IN_284],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_372], ExecError> {
+) -> Result<[G; OUT_284], 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 __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } else { aiur_fn_245(__args, record, io_buffer, __cu)? } };
-    let __v_11: G = __r_arr[0];
-    let __v_12: G = G::from_u64(0);
-    let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_11, __v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } else { aiur_fn_334(__args, record, io_buffer, __cu)? } };
-    let __v_13: G = __r_arr[0];
-    let __v_14: G = __r_arr[1];
-    match __v_13.as_canonical_u64() {
+    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_284] = [__v_0];
+        record.function_queries[284].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
       0u64 => {
-        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 = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; 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_372] = [__v_15, __v_19];
-        record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __v_5: G = G::from_u64(0);
+        let __r_arr: [G; OUT_285] = { let __args: [G; IN_285] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[285].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_285] = unsafe { *(result.output.as_ptr() as *const [G; OUT_285]) }; __ret } else { aiur_fn_285(__args, record, io_buffer, __cu)? } };
+        let __v_6: G = __r_arr[0];
+        let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } else { aiur_fn_284(__args, record, io_buffer, __cu)? } };
+        let __v_7: G = __r_arr[0];
+        let __v_8: G = { let __values: [G; 3] = [__v_5, __v_6, __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_284] = [__v_8];
+        record.function_queries[284].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_285: usize = 2;
+const IN_285: usize = 2;
+const OUT_285: usize = 1;
+fn aiur_fn_285(
+  inp: [G; IN_285],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_285], 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 __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } else { aiur_fn_243(__args, record, io_buffer, __cu)? } };
-        let __v_15: G = __r_arr[0];
-        let __v_16: G = G::from_u64(0);
-        let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_15, __v_10, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } else { aiur_fn_334(__args, record, io_buffer, __cu)? } };
-        let __v_17: G = __r_arr[0];
-        let __v_18: G = __r_arr[1];
-        match __v_17.as_canonical_u64() {
-          0u64 => {
-            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 = { let __values: [G; 4] = [__v_20, __v_21, __v_22, __v_22]; 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_372] = [__v_19, __v_23];
-            record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          1u64 => {
-            let __mc_out___mc_0: [G; 2] = '__mc_0: { match __v_2.as_canonical_u64() {
+        let __ret: [G; OUT_285] = [__v_0];
+        record.function_queries[285].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_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_5: G = __loaded[0];
+        let __v_6: G = __loaded[1];
+        let __v_7: G = __loaded[2];
+        match __v_5.as_canonical_u64() {
+          _ => {
+            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_8: G = __loaded[0];
+            let __v_9: G = __loaded[1];
+            let __v_10: G = __loaded[2];
+            match __v_8.as_canonical_u64() {
+              _ => {
+                let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_8, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } else { aiur_fn_272(__args, record, io_buffer, __cu)? } };
+                let __v_11: G = __r_arr[0];
+                match __v_11.as_canonical_u64() {
+                  0u64 => {
+                    let __r_arr: [G; OUT_285] = { let __args: [G; IN_285] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[285].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_285] = unsafe { *(result.output.as_ptr() as *const [G; OUT_285]) }; __ret } else { aiur_fn_285(__args, record, io_buffer, __cu)? } };
+                    let __v_12: G = __r_arr[0];
+                    let __ret: [G; OUT_285] = [__v_12];
+                    record.function_queries[285].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
+                  },
+                  _ => {
+                    let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[273].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_273] = unsafe { *(result.output.as_ptr() as *const [G; OUT_273]) }; __ret } else { aiur_fn_273(__args, record, io_buffer, __cu)? } };
+                    let __v_12: G = __r_arr[0];
+                    let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_6.as_canonical_u64() {
+  0u64 => {
+    let __v_13: G = G::from_u64(0);
+    break '__mc_0 [__v_13];
+  },
+  _ => {
+    let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_12.as_canonical_u64() {
   1u64 => {
-    let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[302].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_302] = unsafe { *(result.output.as_ptr() as *const [G; OUT_302]) }; __ret } else { aiur_fn_302(__args, record, io_buffer, __cu)? } };
-    let __v_19: G = __r_arr[0];
-    let __v_20: G = G::from_u64(0);
-    let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_19, __v_10, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } else { aiur_fn_334(__args, record, io_buffer, __cu)? } };
-    let __v_21: G = __r_arr[0];
-    let __v_22: G = __r_arr[1];
-    break '__mc_0 [__v_21, __v_22];
+    let __v_13: G = G::from_u64(1);
+    break '__mc_1 [__v_13];
   },
   0u64 => {
-    let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[303].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_303] = unsafe { *(result.output.as_ptr() as *const [G; OUT_303]) }; __ret } else { aiur_fn_303(__args, record, io_buffer, __cu)? } };
-    let __v_19: G = __r_arr[0];
-    let __v_20: G = G::from_u64(0);
-    let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_19, __v_10, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } else { aiur_fn_334(__args, record, io_buffer, __cu)? } };
-    let __v_21: G = __r_arr[0];
-    let __v_22: G = __r_arr[1];
-    break '__mc_0 [__v_21, __v_22];
+    let __v_13: G = { let __a_val = __v_9.as_canonical_u64(); let __b_val = __v_6.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 };
+    break '__mc_1 [__v_13];
   },
   _ => {
-    return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+    return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64()));
   },
 }
  };
-            let __v_19: G = __mc_out___mc_0[0];
-            let __v_20: G = __mc_out___mc_0[1];
-            match __v_19.as_canonical_u64() {
-              0u64 => {
-                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 __v_24: G = G::from_u64(0);
-                let __v_25: G = { let __values: [G; 4] = [__v_22, __v_23, __v_24, __v_24]; 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_372] = [__v_21, __v_25];
-                record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              1u64 => {
-                let __v_21: G = G::from_u64(1);
-                let __v_22: G = G::from_u64(0);
-                let __v_23: G = G::from_u64(0);
-                let __v_24: G = { let __values: [G; 3] = [__v_22, __v_23, __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 __v_25: G = G::from_u64(0);
-                let __v_26: G = { let __values: [G; 3] = [__v_21, __v_24, __v_25]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_27: G = G::from_u64(0);
-                let __v_28: G = G::from_u64(1);
-                let __v_29: G = G::from_u64(1);
-                let __v_30: G = { let __values: [G; 3] = [__v_28, __v_29, __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_27, __v_26, __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 = G::from_u64(2);
-                let __v_33: G = G::from_u64(0);
-                let __v_34: G = { let __values: [G; 4] = [__v_32, __v_14, __v_31, __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 __v_35: G = G::from_u64(2);
-                let __v_36: G = G::from_u64(1);
-                let __v_37: G = G::from_u64(1);
-                let __v_38: G = { let __values: [G; 3] = [__v_36, __v_37, __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 = G::from_u64(0);
-                let __v_40: G = { let __values: [G; 4] = [__v_35, __v_18, __v_38, __v_39]; 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_41: G = G::from_u64(2);
-                let __v_42: G = G::from_u64(1);
-                let __v_43: G = G::from_u64(1);
-                let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __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 = G::from_u64(0);
-                let __v_46: G = { let __values: [G; 4] = [__v_41, __v_20, __v_44, __v_45]; 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_47: G = G::from_u64(3);
-                let __v_48: G = G::from_u64(0);
-                let __v_49: G = { let __values: [G; 4] = [__v_47, __v_34, __v_40, __v_48]; 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_50: G = G::from_u64(3);
-                let __v_51: G = G::from_u64(0);
-                let __v_52: G = { let __values: [G; 4] = [__v_50, __v_49, __v_46, __v_51]; 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 __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_0.as_canonical_u64() {
+    let __v_13: G = __mc_out___mc_1[0];
+    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_14: G = __loaded[0];
+    let __v_15: G = __loaded[1];
+    let __v_16: G = __loaded[2];
+    let __mc_out___mc_2: [G; 1] = '__mc_2: { match __v_14.as_canonical_u64() {
   1u64 => {
-    match __v_2.as_canonical_u64() {
-      1u64 => {
-        let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[258].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_258] = unsafe { *(result.output.as_ptr() as *const [G; OUT_258]) }; __ret } else { aiur_fn_258(__args, record, io_buffer, __cu)? } };
-        let __v_53: G = __r_arr[0];
-        break '__mc_1 [__v_53];
-      },
+    let __v_17: G = G::from_u64(1);
+    break '__mc_2 [__v_17];
+  },
+  0u64 => {
+    let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[277].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_277] = unsafe { *(result.output.as_ptr() as *const [G; OUT_277]) }; __ret } else { aiur_fn_277(__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_17 + __v_18);
+    let __v_20: G = { let __a_val = __v_19.as_canonical_u64(); let __b_val = __v_6.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 };
+    break '__mc_2 [__v_20];
+  },
+  _ => {
+    return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64()));
+  },
+}
+ };
+    let __v_17: G = __mc_out___mc_2[0];
+    let __v_18: G = (__v_13 * __v_17);
+    match __v_18.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_259] = { let __args: [G; IN_259] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[259].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_259] = unsafe { *(result.output.as_ptr() as *const [G; OUT_259]) }; __ret } else { aiur_fn_259(__args, record, io_buffer, __cu)? } };
-        let __v_53: G = __r_arr[0];
-        break '__mc_1 [__v_53];
+        let __v_19: G = G::from_u64(0);
+        break '__mc_0 [__v_19];
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+        break '__mc_0 [__v_6];
       },
     }
   },
+}
+ };
+                    let __v_13: G = __mc_out___mc_0[0];
+                    let __mc_out___mc_3: [G; 1] = '__mc_3: { match __v_12.as_canonical_u64() {
+  1u64 => {
+    break '__mc_3 [__v_7];
+  },
   0u64 => {
-    match __v_2.as_canonical_u64() {
+    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_14: G = __loaded[0];
+    let __v_15: G = __loaded[1];
+    let __v_16: G = __loaded[2];
+    match __v_14.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[260].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_260] = unsafe { *(result.output.as_ptr() as *const [G; OUT_260]) }; __ret } else { aiur_fn_260(__args, record, io_buffer, __cu)? } };
-        let __v_53: G = __r_arr[0];
-        break '__mc_1 [__v_53];
+        break '__mc_3 [__v_7];
       },
       0u64 => {
-        let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[261].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_261] = unsafe { *(result.output.as_ptr() as *const [G; OUT_261]) }; __ret } else { aiur_fn_261(__args, record, io_buffer, __cu)? } };
-        let __v_53: G = __r_arr[0];
-        break '__mc_1 [__v_53];
+        let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } else { aiur_fn_278(__args, record, io_buffer, __cu)? } };
+        let __v_17: G = __r_arr[0];
+        break '__mc_3 [__v_17];
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+        return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64()));
       },
     }
   },
   _ => {
-    return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64()));
+    return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64()));
   },
 }
  };
-                let __v_53: G = __mc_out___mc_1[0];
-                let __v_54: G = G::from_u64(0);
-                let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_53, __v_10, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } else { aiur_fn_334(__args, record, io_buffer, __cu)? } };
-                let __v_55: G = __r_arr[0];
-                let __v_56: G = __r_arr[1];
-                match __v_55.as_canonical_u64() {
-                  0u64 => {
-                    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 = { let __values: [G; 4] = [__v_58, __v_59, __v_60, __v_60]; 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_372] = [__v_57, __v_61];
-                    record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __v_14: G = __mc_out___mc_3[0];
+                    let __v_15: G = { let __values: [G; 3] = [__v_5, __v_13, __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 __r_arr: [G; OUT_285] = { let __args: [G; IN_285] = [__v_15, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[285].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_285] = unsafe { *(result.output.as_ptr() as *const [G; OUT_285]) }; __ret } else { aiur_fn_285(__args, record, io_buffer, __cu)? } };
+                    let __v_16: G = __r_arr[0];
+                    let __ret: [G; OUT_285] = [__v_16];
+                    record.function_queries[285].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
-                  1u64 => {
-                    let __v_57: G = G::from_u64(1);
-                    let __v_58: G = (__v_57 - __v_2);
-                    let __v_59: G = (__v_0 * __v_58);
-                    match __v_59.as_canonical_u64() {
-                      1u64 => {
-                        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; 4] = [__v_61, __v_62, __v_63, __v_63]; 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_372] = [__v_60, __v_64];
-                        record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                        return Ok(__ret);
-                      },
+                }
+              },
+            }
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_286: usize = 2;
+const IN_286: usize = 2;
+const OUT_286: usize = 1;
+fn aiur_fn_286(
+  inp: [G; IN_286],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_286], 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 __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_5: G = __loaded[0];
+        let __v_6: G = __loaded[1];
+        let __v_7: G = __loaded[2];
+        match __v_5.as_canonical_u64() {
+          1u64 => {
+            let __v_8: G = G::from_u64(1);
+            let __ret: [G; OUT_286] = [__v_8];
+            record.function_queries[286].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          0u64 => {
+            let __v_8: G = G::from_u64(0);
+            let __ret: [G; OUT_286] = [__v_8];
+            record.function_queries[286].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__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_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_5: G = __loaded[0];
+        let __v_6: G = __loaded[1];
+        let __v_7: G = __loaded[2];
+        match __v_5.as_canonical_u64() {
+          1u64 => {
+            let __v_8: G = G::from_u64(0);
+            let __ret: [G; OUT_286] = [__v_8];
+            record.function_queries[286].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_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_8: G = __loaded[0];
+            let __v_9: G = __loaded[1];
+            let __v_10: G = __loaded[2];
+            match __v_8.as_canonical_u64() {
+              _ => {
+                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_11: G = __loaded[0];
+                let __v_12: G = __loaded[1];
+                let __v_13: G = __loaded[2];
+                match __v_11.as_canonical_u64() {
+                  _ => {
+                    let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[271].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_271] = unsafe { *(result.output.as_ptr() as *const [G; OUT_271]) }; __ret } else { aiur_fn_271(__args, record, io_buffer, __cu)? } };
+                    let __v_14: G = __r_arr[0];
+                    match __v_14.as_canonical_u64() {
                       0u64 => {
-                        let __v_60: G = G::from_u64(2);
-                        let __v_61: G = G::from_u64(1);
-                        let __v_62: G = G::from_u64(1);
-                        let __v_63: G = { let __values: [G; 3] = [__v_61, __v_62, __v_62]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                        let __v_64: G = G::from_u64(0);
-                        let __v_65: G = { let __values: [G; 4] = [__v_60, __v_56, __v_63, __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 __v_66: G = G::from_u64(3);
-                        let __v_67: G = G::from_u64(0);
-                        let __v_68: G = { let __values: [G; 4] = [__v_66, __v_65, __v_3, __v_67]; 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_69: G = G::from_u64(3);
-                        let __v_70: G = G::from_u64(0);
-                        let __v_71: G = { let __values: [G; 4] = [__v_69, __v_68, __v_4, __v_70]; 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_72: G = G::from_u64(3);
-                        let __v_73: G = G::from_u64(0);
-                        let __v_74: G = { let __values: [G; 4] = [__v_72, __v_71, __v_52, __v_73]; 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_373] = { let __args: [G; IN_373] = [__v_2, __v_74, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[373].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_373] = unsafe { *(result.output.as_ptr() as *const [G; OUT_373]) }; __ret } else { aiur_fn_373(__args, record, io_buffer, __cu)? } };
-                        let __v_75: G = __r_arr[0];
-                        let __v_76: G = __r_arr[1];
-                        let __ret: [G; OUT_372] = [__v_75, __v_76];
-                        record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                        return Ok(__ret);
+                        let __v_15: G = (__v_9 - __v_12);
+                        match __v_15.as_canonical_u64() {
+                          0u64 => {
+                            let __r_arr: [G; OUT_276] = { let __args: [G; IN_276] = [__v_10, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[276].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_276] = unsafe { *(result.output.as_ptr() as *const [G; OUT_276]) }; __ret } else { aiur_fn_276(__args, record, io_buffer, __cu)? } };
+                            let __v_16: G = __r_arr[0];
+                            match __v_16.as_canonical_u64() {
+                              1u64 => {
+                                let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } else { aiur_fn_286(__args, record, io_buffer, __cu)? } };
+                                let __v_17: G = __r_arr[0];
+                                let __ret: [G; OUT_286] = [__v_17];
+                                record.function_queries[286].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                return Ok(__ret);
+                              },
+                              0u64 => {
+                                let __v_17: G = G::from_u64(0);
+                                let __ret: [G; OUT_286] = [__v_17];
+                                record.function_queries[286].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                return Ok(__ret);
+                              },
+                              _ => {
+                                return Err(ExecError::MatchNoCase(__v_16.as_canonical_u64()));
+                              },
+                            }
+                          },
+                          _ => {
+                            let __v_16: G = G::from_u64(0);
+                            let __ret: [G; OUT_286] = [__v_16];
+                            record.function_queries[286].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            return Ok(__ret);
+                          },
+                        }
                       },
                       _ => {
-                        return Err(ExecError::MatchNoCase(__v_59.as_canonical_u64()));
+                        let __v_15: G = G::from_u64(0);
+                        let __ret: [G; OUT_286] = [__v_15];
+                        record.function_queries[286].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        return Ok(__ret);
                       },
                     }
                   },
-                  _ => {
-                    return Err(ExecError::MatchNoCase(__v_55.as_canonical_u64()));
-                  },
                 }
               },
-              _ => {
-                return Err(ExecError::MatchNoCase(__v_19.as_canonical_u64()));
-              },
             }
           },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_17.as_canonical_u64()));
+            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
           },
         }
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64()));
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_373: usize = 8;
-const IN_373: usize = 8;
-const OUT_373: usize = 2;
-fn aiur_fn_373(
-  inp: [G; IN_373],
+const INPUT_SIZE_287: usize = 3;
+const IN_287: usize = 3;
+const OUT_287: usize = 1;
+fn aiur_fn_287(
+  inp: [G; IN_287],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_373], ExecError> {
+) -> Result<[G; OUT_287], 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 __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_0.as_canonical_u64() {
-  1u64 => {
-    let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[256].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_256] = unsafe { *(result.output.as_ptr() as *const [G; OUT_256]) }; __ret } else { aiur_fn_256(__args, record, io_buffer, __cu)? } };
-    let __v_8: G = __r_arr[0];
-    break '__mc_0 [__v_8];
-  },
+    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(0);
+        let __ret: [G; OUT_287] = [__v_6];
+        record.function_queries[287].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_6: G = __loaded[0];
+        let __v_7: G = __loaded[1];
+        let __v_8: G = __loaded[2];
+        match __v_6.as_canonical_u64() {
+          _ => {
+            let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } else { aiur_fn_272(__args, record, io_buffer, __cu)? } };
+            let __v_9: G = __r_arr[0];
+            match __v_9.as_canonical_u64() {
+              0u64 => {
+                let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } else { aiur_fn_287(__args, record, io_buffer, __cu)? } };
+                let __v_10: G = __r_arr[0];
+                let __ret: [G; OUT_287] = [__v_10];
+                record.function_queries[287].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                let __v_10: G = { let __a_val = __v_7.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 };
+                let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_10.as_canonical_u64() {
   0u64 => {
-    let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[257].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_257] = unsafe { *(result.output.as_ptr() as *const [G; OUT_257]) }; __ret } else { aiur_fn_257(__args, record, io_buffer, __cu)? } };
-    let __v_8: G = __r_arr[0];
-    break '__mc_0 [__v_8];
+    let __v_11: G = G::from_u64(1);
+    break '__mc_0 [__v_11];
+  },
+  1u64 => {
+    let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[288].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_288] = unsafe { *(result.output.as_ptr() as *const [G; OUT_288]) }; __ret } else { aiur_fn_288(__args, record, io_buffer, __cu)? } };
+    let __v_11: G = __r_arr[0];
+    break '__mc_0 [__v_11];
   },
   _ => {
-    return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64()));
+    return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64()));
   },
 }
  };
-    let __v_8: G = __mc_out___mc_0[0];
-    let __v_9: G = G::from_u64(0);
-    let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_8, __v_7, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } else { aiur_fn_334(__args, record, io_buffer, __cu)? } };
-    let __v_10: G = __r_arr[0];
-    let __v_11: G = __r_arr[1];
-    match __v_10.as_canonical_u64() {
-      0u64 => {
-        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 = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; 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_373] = [__v_12, __v_16];
-        record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      1u64 => {
-        let __v_12: G = G::from_u64(2);
-        let __v_13: G = G::from_u64(0);
-        let __v_14: G = { let __values: [G; 4] = [__v_12, __v_2, __v_3, __v_13]; 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_15: G = G::from_u64(2);
-        let __r_arr: [G; OUT_792] = { let __args: [G; IN_792] = [__v_4, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[792].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_792] = unsafe { *(result.output.as_ptr() as *const [G; OUT_792]) }; __ret } else { aiur_fn_792(__args, record, io_buffer, __cu)? } };
-        let __v_16: G = __r_arr[0];
-        let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_14, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[427].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_427] = unsafe { *(result.output.as_ptr() as *const [G; OUT_427]) }; __ret } else { aiur_fn_427(__args, record, io_buffer, __cu)? } };
-        let __v_17: G = __r_arr[0];
-        let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_17, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[459].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_459] = unsafe { *(result.output.as_ptr() as *const [G; OUT_459]) }; __ret } else { aiur_fn_459(__args, record, io_buffer, __cu)? } };
-        let __v_18: G = __r_arr[0];
-        let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_18, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } };
-        let __v_19: G = __r_arr[0];
-        let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[189].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_189] = unsafe { *(result.output.as_ptr() as *const [G; OUT_189]) }; __ret } else { aiur_fn_189(__args, record, io_buffer, __cu)? } };
-        let __v_20: G = __r_arr[0];
-        let __v_21: G = __r_arr[1];
-        let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { 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_22: G = __r_arr[0];
-        let __v_23: G = G::from_u64(1);
-        let __v_24: G = { let __a_val = __v_22.as_canonical_u64(); let __b_val = __v_23.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_24.as_canonical_u64() {
-          1u64 => {
-            let __v_25: G = G::from_u64(0);
-            let __v_26: G = G::from_u64(0);
-            let __v_27: G = G::from_u64(0);
-            let __v_28: G = G::from_u64(0);
-            let __v_29: G = { let __values: [G; 4] = [__v_26, __v_27, __v_28, __v_28]; 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_373] = [__v_25, __v_29];
-            record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          0u64 => {
-            let __v_25: G = G::from_u64(0);
-            let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_21, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-            let __v_26: G = __r_arr[0];
-            let __v_27: G = G::from_u64(2);
-            let __v_28: G = G::from_u64(1);
-            let __v_29: G = G::from_u64(1);
-            let __v_30: G = { let __values: [G; 3] = [__v_28, __v_29, __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 = G::from_u64(0);
-            let __v_32: G = { let __values: [G; 4] = [__v_27, __v_11, __v_30, __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 = G::from_u64(3);
-            let __v_34: G = G::from_u64(0);
-            let __v_35: G = { let __values: [G; 4] = [__v_33, __v_32, __v_26, __v_34]; 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_36: G = G::from_u64(3);
-            let __v_37: G = G::from_u64(0);
-            let __v_38: G = { let __values: [G; 4] = [__v_36, __v_35, __v_1, __v_37]; 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_39: G = G::from_u64(2);
-            let __r_arr: [G; OUT_796] = { let __args: [G; IN_796] = [__v_4, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[796].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_796] = unsafe { *(result.output.as_ptr() as *const [G; OUT_796]) }; __ret } else { aiur_fn_796(__args, record, io_buffer, __cu)? } };
-            let __v_40: G = __r_arr[0];
-            let __v_41: G = G::from_u64(1);
-            let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_38, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[427].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_427] = unsafe { *(result.output.as_ptr() as *const [G; OUT_427]) }; __ret } else { aiur_fn_427(__args, record, io_buffer, __cu)? } };
-            let __v_42: G = __r_arr[0];
-            let __ret: [G; OUT_373] = [__v_41, __v_42];
-            record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_24.as_canonical_u64()));
+                let __v_11: G = __mc_out___mc_0[0];
+                match __v_11.as_canonical_u64() {
+                  1u64 => {
+                    let __v_12: G = G::from_u64(1);
+                    let __ret: [G; OUT_287] = [__v_12];
+                    record.function_queries[287].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
+                  },
+                  0u64 => {
+                    let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } else { aiur_fn_287(__args, record, io_buffer, __cu)? } };
+                    let __v_12: G = __r_arr[0];
+                    let __ret: [G; OUT_287] = [__v_12];
+                    record.function_queries[287].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
+                  },
+                  _ => {
+                    return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64()));
+                  },
+                }
+              },
+            }
           },
         }
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64()));
+        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_374: usize = 6;
-const IN_374: usize = 6;
-const OUT_374: usize = 2;
-fn aiur_fn_374(
-  inp: [G; IN_374],
+const INPUT_SIZE_288: usize = 2;
+const IN_288: usize = 2;
+const OUT_288: usize = 1;
+fn aiur_fn_288(
+  inp: [G; IN_288],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_374], ExecError> {
+) -> Result<[G; OUT_288], 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_298] = { let __args: [G; IN_298] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } else { aiur_fn_298(__args, record, io_buffer, __cu)? } };
-    let __v_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_7: G = __r_arr[0];
-    let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[299].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_299] = unsafe { *(result.output.as_ptr() as *const [G; OUT_299]) }; __ret } else { aiur_fn_299(__args, record, io_buffer, __cu)? } };
-    let __v_8: G = __r_arr[0];
-    let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_9: G = __r_arr[0];
-    let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } else { aiur_fn_297(__args, record, io_buffer, __cu)? } };
-    let __v_10: G = __r_arr[0];
-    let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_11: G = __r_arr[0];
-    match __v_11.as_canonical_u64() {
+    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 __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[378].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_378] = unsafe { *(result.output.as_ptr() as *const [G; OUT_378]) }; __ret } else { aiur_fn_378(__args, record, io_buffer, __cu)? } };
-        let __v_12: G = __r_arr[0];
-        let __v_13: G = __r_arr[1];
-        let __ret: [G; OUT_374] = [__v_12, __v_13];
-        record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __v_5: G = G::from_u64(0);
+        let __ret: [G; OUT_288] = [__v_5];
+        record.function_queries[288].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __v_12: G = (__v_7 + __v_9);
-        match __v_12.as_canonical_u64() {
-          0u64 => {
-            let __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_0, __v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[375].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_375] = unsafe { *(result.output.as_ptr() as *const [G; OUT_375]) }; __ret } else { aiur_fn_375(__args, record, io_buffer, __cu)? } };
-            let __v_13: G = __r_arr[0];
-            let __v_14: G = __r_arr[1];
-            let __ret: [G; OUT_374] = [__v_13, __v_14];
-            record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; 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: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_5: G = __loaded[0];
+        let __v_6: G = __loaded[1];
+        match __v_5.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_376] = { let __args: [G; IN_376] = [__v_7, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[376].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_376] = unsafe { *(result.output.as_ptr() as *const [G; OUT_376]) }; __ret } else { aiur_fn_376(__args, record, io_buffer, __cu)? } };
-            let __v_13: G = __r_arr[0];
-            let __v_14: G = __r_arr[1];
-            let __ret: [G; OUT_374] = [__v_13, __v_14];
-            record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
+            let __v_7: G = G::from_u64(1);
+            let __v_8: G = (__v_6 + __v_7);
+            let __v_9: G = { let __a_val = __v_8.as_canonical_u64(); let __b_val = __v_1.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_9.as_canonical_u64() {
+              0u64 => {
+                let __v_10: G = G::from_u64(1);
+                let __ret: [G; OUT_288] = [__v_10];
+                record.function_queries[288].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              1u64 => {
+                let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[288].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_288] = unsafe { *(result.output.as_ptr() as *const [G; OUT_288]) }; __ret } else { aiur_fn_288(__args, record, io_buffer, __cu)? } };
+                let __v_10: G = __r_arr[0];
+                let __ret: [G; OUT_288] = [__v_10];
+                record.function_queries[288].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64()));
+              },
+            }
           },
         }
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64()));
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_375: usize = 3;
-const IN_375: usize = 3;
-const OUT_375: usize = 2;
-fn aiur_fn_375(
-  inp: [G; IN_375],
+const INPUT_SIZE_289: usize = 4;
+const IN_289: usize = 4;
+const OUT_289: usize = 1;
+fn aiur_fn_289(
+  inp: [G; IN_289],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_375], ExecError> {
+) -> Result<[G; OUT_289], 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_187] = { let __args: [G; IN_187] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { 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_3: G = __r_arr[0];
-    let __v_4: G = G::from_u64(1);
-    let __v_5: G = { let __a_val = __v_3.as_canonical_u64(); let __b_val = __v_4.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() {
+    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_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_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_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 = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_9]; 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_375] = [__v_6, __v_10];
-        record.function_queries[375].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_289] = [__v_7];
+        record.function_queries[289].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __v_6: G = G::from_u64(0);
-        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-        let __v_7: 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_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: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].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];
-        match __v_8.as_canonical_u64() {
-          7u64 => {
-            match __v_9.as_canonical_u64() {
-              1u64 => {
-                let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } else { aiur_fn_290(__args, record, io_buffer, __cu)? } };
-                let __v_12: G = __r_arr[0];
-                let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_13: G = __r_arr[0];
-                match __v_13.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_7: G = __loaded[0];
+        let __v_8: G = __loaded[1];
+        let __v_9: G = __loaded[2];
+        match __v_7.as_canonical_u64() {
+          _ => {
+            let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } else { aiur_fn_272(__args, record, io_buffer, __cu)? } };
+            let __v_10: G = __r_arr[0];
+            match __v_10.as_canonical_u64() {
+              0u64 => {
+                let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } else { aiur_fn_289(__args, record, io_buffer, __cu)? } };
+                let __v_11: G = __r_arr[0];
+                let __ret: [G; OUT_289] = [__v_11];
+                record.function_queries[289].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_9, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } else { aiur_fn_290(__args, record, io_buffer, __cu)? } };
+                let __v_11: G = __r_arr[0];
+                match __v_11.as_canonical_u64() {
                   1u64 => {
-                    let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[772].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_772] = unsafe { *(result.output.as_ptr() as *const [G; OUT_772]) }; __ret } else { aiur_fn_772(__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 __v_17: G = __r_arr[3];
-                    let __v_18: G = __r_arr[4];
-                    let __v_19: G = __r_arr[5];
-                    let __v_20: G = __r_arr[6];
-                    let __v_21: G = __r_arr[7];
-                    let __v_22: G = G::from_u64(0);
-                    let __v_23: G = G::from_u64(1);
-                    let __v_24: G = G::from_u64(1);
-                    let __v_25: G = { let __values: [G; 10] = [__v_23, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24]; 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_26: G = { let __values: [G; 10] = [__v_22, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_25]; 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_27: G = G::from_u64(1);
-                    let __v_28: G = G::from_u64(7);
-                    let __v_29: G = G::from_u64(0);
-                    let __v_30: G = G::from_u64(0);
-                    let __v_31: G = { let __values: [G; 4] = [__v_28, __v_29, __v_26, __v_30]; 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_375] = [__v_27, __v_31];
-                    record.function_queries[375].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __v_12: G = G::from_u64(1);
+                    let __ret: [G; OUT_289] = [__v_12];
+                    record.function_queries[289].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   0u64 => {
-                    let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[293].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_293] = unsafe { *(result.output.as_ptr() as *const [G; OUT_293]) }; __ret } else { aiur_fn_293(__args, record, io_buffer, __cu)? } };
-                    let __v_14: G = __r_arr[0];
-                    let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_15: G = __r_arr[0];
-                    match __v_15.as_canonical_u64() {
-                      1u64 => {
-                        let __r_arr: [G; OUT_386] = { let __args: [G; IN_386] = [__v_10, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[386].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_386] = unsafe { *(result.output.as_ptr() as *const [G; OUT_386]) }; __ret } else { aiur_fn_386(__args, record, io_buffer, __cu)? } };
-                        let __v_16: G = __r_arr[0];
-                        let __v_17: G = __r_arr[1];
-                        let __ret: [G; OUT_375] = [__v_16, __v_17];
-                        record.function_queries[375].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                        return Ok(__ret);
-                      },
-                      0u64 => {
-                        let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[291].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_291] = unsafe { *(result.output.as_ptr() as *const [G; OUT_291]) }; __ret } else { aiur_fn_291(__args, record, io_buffer, __cu)? } };
-                        let __v_16: G = __r_arr[0];
-                        let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_17: G = __r_arr[0];
-                        let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[292].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_292] = unsafe { *(result.output.as_ptr() as *const [G; OUT_292]) }; __ret } else { aiur_fn_292(__args, record, io_buffer, __cu)? } };
-                        let __v_18: G = __r_arr[0];
-                        let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_19: G = __r_arr[0];
-                        let __v_20: G = (__v_17 + __v_19);
-                        match __v_20.as_canonical_u64() {
-                          0u64 => {
-                            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 __v_24: G = G::from_u64(0);
-                            let __v_25: G = { let __values: [G; 4] = [__v_22, __v_23, __v_24, __v_24]; 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_375] = [__v_21, __v_25];
-                            record.function_queries[375].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                            return Ok(__ret);
-                          },
-                          _ => {
-                            let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_10, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[387].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_387] = unsafe { *(result.output.as_ptr() as *const [G; OUT_387]) }; __ret } else { aiur_fn_387(__args, record, io_buffer, __cu)? } };
-                            let __v_21: G = __r_arr[0];
-                            let __v_22: G = __r_arr[1];
-                            let __ret: [G; OUT_375] = [__v_21, __v_22];
-                            record.function_queries[375].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                            return Ok(__ret);
-                          },
-                        }
-                      },
-                      _ => {
-                        return Err(ExecError::MatchNoCase(__v_15.as_canonical_u64()));
-                      },
-                    }
+                    let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } else { aiur_fn_289(__args, record, io_buffer, __cu)? } };
+                    let __v_12: G = __r_arr[0];
+                    let __ret: [G; OUT_289] = [__v_12];
+                    record.function_queries[289].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
                   },
                   _ => {
-                    return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64()));
+                    return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64()));
                   },
                 }
               },
-              _ => {
-                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 = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; 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_375] = [__v_12, __v_16];
-                record.function_queries[375].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
             }
           },
-          _ => {
-            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 = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; 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_375] = [__v_12, __v_16];
-            record.function_queries[375].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
         }
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
+        return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_376: usize = 6;
-const IN_376: usize = 6;
-const OUT_376: usize = 2;
-fn aiur_fn_376(
-  inp: [G; IN_376],
+const INPUT_SIZE_290: usize = 3;
+const IN_290: usize = 3;
+const OUT_290: usize = 1;
+fn aiur_fn_290(
+  inp: [G; IN_290],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_376], ExecError> {
+) -> Result<[G; OUT_290], 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_187] = { let __args: [G; IN_187] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { 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_6: G = __r_arr[0];
-    match __v_6.as_canonical_u64() {
-      2u64 => {
-        let __v_7: G = G::from_u64(0);
-        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-        let __v_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_8, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } };
-        let __v_9: 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_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: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].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];
-        match __v_10.as_canonical_u64() {
-          7u64 => {
-            match __v_11.as_canonical_u64() {
-              1u64 => {
-                let __v_14: G = G::from_u64(1);
-                let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_2, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-                let __v_15: G = __r_arr[0];
-                let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_15, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } };
-                let __v_16: 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_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: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].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];
-                match __v_17.as_canonical_u64() {
-                  7u64 => {
-                    match __v_18.as_canonical_u64() {
-                      1u64 => {
-                        match __v_0.as_canonical_u64() {
-                          1u64 => {
-                            let __r_arr: [G; OUT_773] = { let __args: [G; IN_773] = [__v_12, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[773].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_773] = unsafe { *(result.output.as_ptr() as *const [G; OUT_773]) }; __ret } else { aiur_fn_773(__args, record, io_buffer, __cu)? } };
-                            let __v_21: G = __r_arr[0];
-                            let __v_22: G = G::from_u64(1);
-                            let __v_23: G = G::from_u64(7);
-                            let __v_24: G = G::from_u64(1);
-                            let __v_25: G = G::from_u64(0);
-                            let __v_26: G = { let __values: [G; 4] = [__v_23, __v_24, __v_21, __v_25]; 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_376] = [__v_22, __v_26];
-                            record.function_queries[376].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                            return Ok(__ret);
-                          },
-                          0u64 => {
-                            let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_12, __v_19, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = unsafe { *(result.output.as_ptr() as *const [G; OUT_377]) }; __ret } else { aiur_fn_377(__args, record, io_buffer, __cu)? } };
-                            let __v_21: G = __r_arr[0];
-                            let __v_22: G = __r_arr[1];
-                            let __ret: [G; OUT_376] = [__v_21, __v_22];
-                            record.function_queries[376].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                            return Ok(__ret);
-                          },
-                          _ => {
-                            return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64()));
-                          },
-                        }
-                      },
-                      _ => {
-                        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 __v_24: G = G::from_u64(0);
-                        let __v_25: G = { let __values: [G; 4] = [__v_22, __v_23, __v_24, __v_24]; 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_376] = [__v_21, __v_25];
-                        record.function_queries[376].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_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(0);
+        let __ret: [G; OUT_290] = [__v_6];
+        record.function_queries[290].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; 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: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_6: G = __loaded[0];
+        let __v_7: G = __loaded[1];
+        match __v_6.as_canonical_u64() {
+          _ => {
+            let __v_8: G = (__v_6 - __v_1);
+            match __v_8.as_canonical_u64() {
+              0u64 => {
+                let __v_9: G = { let __a_val = __v_7.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_9.as_canonical_u64() {
+                  0u64 => {
+                    let __v_10: G = G::from_u64(1);
+                    let __ret: [G; OUT_290] = [__v_10];
+                    record.function_queries[290].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
                   },
-                  _ => {
-                    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 __v_24: G = G::from_u64(0);
-                    let __v_25: G = { let __values: [G; 4] = [__v_22, __v_23, __v_24, __v_24]; 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_376] = [__v_21, __v_25];
-                    record.function_queries[376].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                  1u64 => {
+                    let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } else { aiur_fn_290(__args, record, io_buffer, __cu)? } };
+                    let __v_10: G = __r_arr[0];
+                    let __ret: [G; OUT_290] = [__v_10];
+                    record.function_queries[290].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
+                  _ => {
+                    return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64()));
+                  },
                 }
               },
               _ => {
-                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 = G::from_u64(0);
-                let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; 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_376] = [__v_14, __v_18];
-                record.function_queries[376].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } else { aiur_fn_290(__args, record, io_buffer, __cu)? } };
+                let __v_9: G = __r_arr[0];
+                let __ret: [G; OUT_290] = [__v_9];
+                record.function_queries[290].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
-          _ => {
-            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 = G::from_u64(0);
-            let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; 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_376] = [__v_14, __v_18];
-            record.function_queries[376].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
         }
       },
       _ => {
-        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 = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __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_376] = [__v_7, __v_11];
-        record.function_queries[376].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
+        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_377: usize = 7;
-const IN_377: usize = 7;
-const OUT_377: usize = 2;
-fn aiur_fn_377(
-  inp: [G; IN_377],
+const INPUT_SIZE_291: usize = 2;
+const IN_291: usize = 2;
+const OUT_291: usize = 1;
+fn aiur_fn_291(
+  inp: [G; IN_291],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_377], ExecError> {
+) -> Result<[G; OUT_291], 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 __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[231].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_231] = unsafe { *(result.output.as_ptr() as *const [G; OUT_231]) }; __ret } else { aiur_fn_231(__args, record, io_buffer, __cu)? } };
-    let __v_7: G = __r_arr[0];
-    match __v_7.as_canonical_u64() {
-      0u64 => {
-        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 = { let __values: [G; 4] = [__v_9, __v_10, __v_11, __v_11]; 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_377] = [__v_8, __v_12];
-        record.function_queries[377].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_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_291] = [__v_5];
+        record.function_queries[291].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      1u64 => {
-        let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } else { aiur_fn_245(__args, record, io_buffer, __cu)? } };
-        let __v_8: G = __r_arr[0];
-        let __v_9: G = G::from_u64(0);
-        let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_8, __v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } else { aiur_fn_334(__args, record, io_buffer, __cu)? } };
-        let __v_10: G = __r_arr[0];
-        let __v_11: G = __r_arr[1];
-        match __v_10.as_canonical_u64() {
-          0u64 => {
-            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 = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; 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_377] = [__v_12, __v_16];
-            record.function_queries[377].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          1u64 => {
-            let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } else { aiur_fn_289(__args, record, io_buffer, __cu)? } };
-            let __v_12: G = __r_arr[0];
-            let __v_13: G = G::from_u64(0);
-            let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_12, __v_6, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } else { aiur_fn_334(__args, record, io_buffer, __cu)? } };
-            let __v_14: G = __r_arr[0];
-            let __v_15: G = __r_arr[1];
-            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_5: G = __loaded[0];
+        let __v_6: G = __loaded[1];
+        let __v_7: G = __loaded[2];
+        match __v_5.as_canonical_u64() {
+          _ => {
+            let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_6.as_canonical_u64() {
+  0u64 => {
+    let __v_8: G = G::from_u64(1);
+    break '__mc_0 [__v_8];
+  },
+  _ => {
+    let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_1, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } else { aiur_fn_287(__args, record, io_buffer, __cu)? } };
+    let __v_8: G = __r_arr[0];
+    break '__mc_0 [__v_8];
+  },
+}
+ };
+            let __v_8: G = __mc_out___mc_0[0];
+            match __v_8.as_canonical_u64() {
               0u64 => {
-                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 = { let __values: [G; 4] = [__v_17, __v_18, __v_19, __v_19]; 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_377] = [__v_16, __v_20];
-                record.function_queries[377].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __v_9: G = G::from_u64(0);
+                let __ret: [G; OUT_291] = [__v_9];
+                record.function_queries[291].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               1u64 => {
-                let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[256].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_256] = unsafe { *(result.output.as_ptr() as *const [G; OUT_256]) }; __ret } else { aiur_fn_256(__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_334] = { let __args: [G; IN_334] = [__v_16, __v_6, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } else { aiur_fn_334(__args, record, io_buffer, __cu)? } };
-                let __v_18: G = __r_arr[0];
-                let __v_19: G = __r_arr[1];
-                match __v_18.as_canonical_u64() {
+                let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_7, __v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[292].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_292] = unsafe { *(result.output.as_ptr() as *const [G; OUT_292]) }; __ret } else { aiur_fn_292(__args, record, io_buffer, __cu)? } };
+                let __v_9: G = __r_arr[0];
+                match __v_9.as_canonical_u64() {
                   0u64 => {
-                    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 __v_24: G = { let __values: [G; 4] = [__v_21, __v_22, __v_23, __v_23]; 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_377] = [__v_20, __v_24];
-                    record.function_queries[377].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __v_10: G = G::from_u64(0);
+                    let __ret: [G; OUT_291] = [__v_10];
+                    record.function_queries[291].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   1u64 => {
-                    let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[427].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_427] = unsafe { *(result.output.as_ptr() as *const [G; OUT_427]) }; __ret } else { aiur_fn_427(__args, record, io_buffer, __cu)? } };
-                    let __v_20: G = __r_arr[0];
-                    let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_20, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[459].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_459] = unsafe { *(result.output.as_ptr() as *const [G; OUT_459]) }; __ret } else { aiur_fn_459(__args, record, io_buffer, __cu)? } };
-                    let __v_21: G = __r_arr[0];
-                    let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_21, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } };
-                    let __v_22: G = __r_arr[0];
-                    let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[189].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_189] = unsafe { *(result.output.as_ptr() as *const [G; OUT_189]) }; __ret } else { aiur_fn_189(__args, record, io_buffer, __cu)? } };
-                    let __v_23: G = __r_arr[0];
-                    let __v_24: G = __r_arr[1];
-                    let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { 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_25: G = __r_arr[0];
-                    let __v_26: G = G::from_u64(1);
-                    let __v_27: G = { let __a_val = __v_25.as_canonical_u64(); let __b_val = __v_26.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_27.as_canonical_u64() {
-                      1u64 => {
-                        let __v_28: G = G::from_u64(0);
-                        let __v_29: G = G::from_u64(0);
-                        let __v_30: G = G::from_u64(0);
-                        let __v_31: G = G::from_u64(0);
-                        let __v_32: G = { let __values: [G; 4] = [__v_29, __v_30, __v_31, __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 __ret: [G; OUT_377] = [__v_28, __v_32];
-                        record.function_queries[377].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                        return Ok(__ret);
-                      },
-                      0u64 => {
-                        let __v_28: G = G::from_u64(0);
-                        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_24, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-                        let __v_29: G = __r_arr[0];
-                        let __v_30: G = G::from_u64(1);
-                        let __v_31: G = G::from_u64(0);
-                        let __v_32: G = G::from_u64(0);
-                        let __v_33: G = { let __values: [G; 3] = [__v_31, __v_32, __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 = G::from_u64(0);
-                        let __v_35: G = { let __values: [G; 3] = [__v_30, __v_33, __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(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 = { let __values: [G; 3] = [__v_36, __v_35, __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 = G::from_u64(2);
-                        let __v_42: G = G::from_u64(0);
-                        let __v_43: G = { let __values: [G; 4] = [__v_41, __v_11, __v_40, __v_42]; 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_44: G = G::from_u64(2);
-                        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 __v_48: G = G::from_u64(0);
-                        let __v_49: G = { let __values: [G; 4] = [__v_44, __v_15, __v_47, __v_48]; 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_50: G = G::from_u64(7);
-                        let __v_51: G = G::from_u64(1);
-                        let __v_52: G = G::from_u64(0);
-                        let __v_53: G = { let __values: [G; 4] = [__v_50, __v_51, __v_0, __v_52]; 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_54: G = G::from_u64(3);
-                        let __v_55: G = G::from_u64(0);
-                        let __v_56: G = { let __values: [G; 4] = [__v_54, __v_43, __v_49, __v_55]; 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_57: G = G::from_u64(3);
-                        let __v_58: G = G::from_u64(0);
-                        let __v_59: G = { let __values: [G; 4] = [__v_57, __v_56, __v_53, __v_58]; 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_60: G = G::from_u64(2);
-                        let __v_61: G = G::from_u64(1);
-                        let __v_62: G = G::from_u64(1);
-                        let __v_63: G = { let __values: [G; 3] = [__v_61, __v_62, __v_62]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                        let __v_64: G = G::from_u64(0);
-                        let __v_65: G = { let __values: [G; 4] = [__v_60, __v_19, __v_63, __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 __v_66: G = G::from_u64(3);
-                        let __v_67: G = G::from_u64(0);
-                        let __v_68: G = { let __values: [G; 4] = [__v_66, __v_65, __v_29, __v_67]; 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_69: G = G::from_u64(1);
-                        let __v_70: G = G::from_u64(3);
-                        let __v_71: G = G::from_u64(0);
-                        let __v_72: G = { let __values: [G; 4] = [__v_70, __v_68, __v_59, __v_71]; 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_377] = [__v_69, __v_72];
-                        record.function_queries[377].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                        return Ok(__ret);
-                      },
-                      _ => {
-                        return Err(ExecError::MatchNoCase(__v_27.as_canonical_u64()));
-                      },
-                    }
+                    let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[291].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_291] = unsafe { *(result.output.as_ptr() as *const [G; OUT_291]) }; __ret } else { aiur_fn_291(__args, record, io_buffer, __cu)? } };
+                    let __v_10: G = __r_arr[0];
+                    let __ret: [G; OUT_291] = [__v_10];
+                    record.function_queries[291].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
                   },
                   _ => {
-                    return Err(ExecError::MatchNoCase(__v_18.as_canonical_u64()));
+                    return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64()));
                   },
                 }
               },
               _ => {
-                return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64()));
+                return Err(ExecError::MatchNoCase(__v_8.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_2.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_378: usize = 4;
-const IN_378: usize = 4;
-const OUT_378: usize = 2;
-fn aiur_fn_378(
-  inp: [G; IN_378],
+const INPUT_SIZE_292: usize = 3;
+const IN_292: usize = 3;
+const OUT_292: usize = 1;
+fn aiur_fn_292(
+  inp: [G; IN_292],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_378], ExecError> {
+) -> Result<[G; OUT_292], 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_187] = { let __args: [G; IN_187] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { 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_4: G = __r_arr[0];
-    match __v_4.as_canonical_u64() {
+    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_5: G = G::from_u64(0);
-        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-        let __v_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_379] = { let __args: [G; IN_379] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[379].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_379] = unsafe { *(result.output.as_ptr() as *const [G; OUT_379]) }; __ret } else { aiur_fn_379(__args, record, io_buffer, __cu)? } };
-        let __v_7: G = __r_arr[0];
-        let __v_8: G = __r_arr[1];
-        match __v_7.as_canonical_u64() {
-          1u64 => {
-            let __v_9: G = G::from_u64(1);
-            let __v_10: G = G::from_u64(7);
-            let __v_11: G = G::from_u64(1);
-            let __v_12: G = G::from_u64(0);
-            let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __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_378] = [__v_9, __v_13];
-            record.function_queries[378].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          0u64 => {
-            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 = { let __values: [G; 4] = [__v_10, __v_11, __v_12, __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_378] = [__v_9, __v_13];
-            record.function_queries[378].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
+        let __v_6: G = G::from_u64(1);
+        let __ret: [G; OUT_292] = [__v_6];
+        record.function_queries[292].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; 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: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __v_6: G = __loaded[0];
+        let __v_7: G = __loaded[1];
+        match __v_6.as_canonical_u64() {
           _ => {
-            return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64()));
+            let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_1, __v_2, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } else { aiur_fn_289(__args, record, io_buffer, __cu)? } };
+            let __v_8: G = __r_arr[0];
+            match __v_8.as_canonical_u64() {
+              0u64 => {
+                let __v_9: G = G::from_u64(0);
+                let __ret: [G; OUT_292] = [__v_9];
+                record.function_queries[292].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              1u64 => {
+                let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[292].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_292] = unsafe { *(result.output.as_ptr() as *const [G; OUT_292]) }; __ret } else { aiur_fn_292(__args, record, io_buffer, __cu)? } };
+                let __v_9: G = __r_arr[0];
+                let __ret: [G; OUT_292] = [__v_9];
+                record.function_queries[292].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64()));
+              },
+            }
           },
         }
       },
       _ => {
-        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; 4] = [__v_6, __v_7, __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_378] = [__v_5, __v_9];
-        record.function_queries[378].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
+        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_379: usize = 4;
-const IN_379: usize = 4;
-const OUT_379: usize = 2;
-fn aiur_fn_379(
-  inp: [G; IN_379],
+const INPUT_SIZE_293: usize = 1;
+const IN_293: usize = 1;
+const OUT_293: usize = 1;
+fn aiur_fn_293(
+  inp: [G; IN_293],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_379], ExecError> {
+) -> Result<[G; OUT_293], 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(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 __v_5: G = G::from_u64(0);
+    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 __v_9: G = { let __values: [G; 3] = [__v_4, __v_5, __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_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 __v_13: G = { let __values: [G; 3] = [__v_1, __v_9, __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 __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 __v_17: G = G::from_u64(0);
+    let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0, __v_16, __v_17, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } else { aiur_fn_282(__args, record, io_buffer, __cu)? } };
+    let __v_18: G = __r_arr[0];
+    let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_18, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } else { aiur_fn_284(__args, record, io_buffer, __cu)? } };
+    let __v_19: G = __r_arr[0];
+    let __ret: [G; OUT_293] = [__v_19];
+    record.function_queries[293].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_294: usize = 2;
+const IN_294: usize = 2;
+const OUT_294: usize = 1;
+fn aiur_fn_294(
+  inp: [G; IN_294],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_294], 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_439] = { let __args: [G; IN_439] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } };
-    let __v_4: G = __r_arr[0];
-    let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[189].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_189] = unsafe { *(result.output.as_ptr() as *const [G; OUT_189]) }; __ret } else { aiur_fn_189(__args, record, io_buffer, __cu)? } };
-    let __v_5: G = __r_arr[0];
-    let __v_6: G = __r_arr[1];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; 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: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].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];
-    match __v_7.as_canonical_u64() {
-      2u64 => {
-        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_3, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-        let __v_11: G = __r_arr[0];
-        let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[300].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_300] = unsafe { *(result.output.as_ptr() as *const [G; OUT_300]) }; __ret } else { aiur_fn_300(__args, record, io_buffer, __cu)? } };
-        let __v_12: G = __r_arr[0];
-        let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_13: G = __r_arr[0];
-        match __v_13.as_canonical_u64() {
-          1u64 => {
-            let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { 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_14: G = __r_arr[0];
-            match __v_14.as_canonical_u64() {
-              1u64 => {
-                let __v_15: G = G::from_u64(1);
-                let __v_16: G = G::from_u64(1);
-                let __v_17: G = G::from_u64(1);
-                let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __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 __ret: [G; OUT_379] = [__v_15, __v_18];
-                record.function_queries[379].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              _ => {
-                let __v_15: G = G::from_u64(0);
-                let __v_16: G = G::from_u64(1);
-                let __v_17: G = G::from_u64(1);
-                let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __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 __ret: [G; OUT_379] = [__v_15, __v_18];
-                record.function_queries[379].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-            }
-          },
+    let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[270].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_270] = unsafe { *(result.output.as_ptr() as *const [G; OUT_270]) }; __ret } else { aiur_fn_270(__args, record, io_buffer, __cu)? } };
+    let __v_2: G = __r_arr[0];
+    match __v_2.as_canonical_u64() {
+      1u64 => {
+        let __v_3: G = G::from_u64(1);
+        let __ret: [G; OUT_294] = [__v_3];
+        record.function_queries[294].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_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() {
           0u64 => {
-            let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[301].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_301] = unsafe { *(result.output.as_ptr() as *const [G; OUT_301]) }; __ret } else { aiur_fn_301(__args, record, io_buffer, __cu)? } };
-            let __v_14: G = __r_arr[0];
-            let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_11, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_15: G = __r_arr[0];
-            match __v_15.as_canonical_u64() {
-              0u64 => {
-                let __v_16: G = G::from_u64(0);
-                let __v_17: G = G::from_u64(1);
-                let __v_18: G = G::from_u64(1);
-                let __v_19: G = { let __values: [G; 3] = [__v_17, __v_18, __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 __ret: [G; OUT_379] = [__v_16, __v_19];
-                record.function_queries[379].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              1u64 => {
-                let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { 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_16: G = __r_arr[0];
-                match __v_16.as_canonical_u64() {
-                  3u64 => {
-                    let __v_17: G = G::from_u64(1);
-                    let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_6, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-                    let __v_18: G = __r_arr[0];
-                    let __r_arr: [G; OUT_380] = { let __args: [G; IN_380] = [__v_18, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[380].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_380] = unsafe { *(result.output.as_ptr() as *const [G; OUT_380]) }; __ret } else { aiur_fn_380(__args, record, io_buffer, __cu)? } };
-                    let __v_19: G = __r_arr[0];
-                    let __v_20: G = __r_arr[1];
-                    match __v_19.as_canonical_u64() {
-                      0u64 => {
-                        let __v_21: G = G::from_u64(0);
-                        let __v_22: G = G::from_u64(1);
-                        let __v_23: G = G::from_u64(1);
-                        let __v_24: G = { let __values: [G; 3] = [__v_22, __v_23, __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_379] = [__v_21, __v_24];
-                        record.function_queries[379].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                        return Ok(__ret);
-                      },
-                      1u64 => {
-                        let __v_21: G = G::from_u64(2);
-                        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_6, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-                        let __v_22: G = __r_arr[0];
-                        let __r_arr: [G; OUT_379] = { let __args: [G; IN_379] = [__v_22, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[379].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_379] = unsafe { *(result.output.as_ptr() as *const [G; OUT_379]) }; __ret } else { aiur_fn_379(__args, record, io_buffer, __cu)? } };
-                        let __v_23: G = __r_arr[0];
-                        let __v_24: G = __r_arr[1];
-                        match __v_23.as_canonical_u64() {
-                          0u64 => {
-                            let __v_25: G = G::from_u64(0);
-                            let __ret: [G; OUT_379] = [__v_25, __v_24];
-                            record.function_queries[379].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                            return Ok(__ret);
-                          },
-                          1u64 => {
-                            let __v_25: G = G::from_u64(1);
-                            let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_20, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = unsafe { *(result.output.as_ptr() as *const [G; OUT_385]) }; __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } };
-                            let __v_26: G = __r_arr[0];
-                            let __ret: [G; OUT_379] = [__v_25, __v_26];
-                            record.function_queries[379].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                            return Ok(__ret);
-                          },
-                          _ => {
-                            return Err(ExecError::MatchNoCase(__v_23.as_canonical_u64()));
-                          },
-                        }
-                      },
-                      _ => {
-                        return Err(ExecError::MatchNoCase(__v_19.as_canonical_u64()));
-                      },
-                    }
-                  },
-                  _ => {
-                    let __v_17: G = G::from_u64(0);
-                    let __v_18: G = G::from_u64(1);
-                    let __v_19: G = G::from_u64(1);
-                    let __v_20: G = { let __values: [G; 3] = [__v_18, __v_19, __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 __ret: [G; OUT_379] = [__v_17, __v_20];
-                    record.function_queries[379].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
-                }
-              },
-              _ => {
-                return Err(ExecError::MatchNoCase(__v_15.as_canonical_u64()));
-              },
-            }
+            let __v_6: G = G::from_u64(1);
+            let __ret: [G; OUT_294] = [__v_6];
+            record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
           },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64()));
+            let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[293].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_293] = unsafe { *(result.output.as_ptr() as *const [G; OUT_293]) }; __ret } else { aiur_fn_293(__args, record, io_buffer, __cu)? } };
+            let __v_6: G = __r_arr[0];
+            let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[293].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_293] = unsafe { *(result.output.as_ptr() as *const [G; OUT_293]) }; __ret } else { aiur_fn_293(__args, record, io_buffer, __cu)? } };
+            let __v_7: G = __r_arr[0];
+            let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[291].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_291] = unsafe { *(result.output.as_ptr() as *const [G; OUT_291]) }; __ret } else { aiur_fn_291(__args, record, io_buffer, __cu)? } };
+            let __v_8: G = __r_arr[0];
+            let __ret: [G; OUT_294] = [__v_8];
+            record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
           },
         }
       },
       _ => {
-        let __v_11: G = G::from_u64(0);
-        let __v_12: G = G::from_u64(1);
-        let __v_13: G = G::from_u64(1);
-        let __v_14: G = { let __values: [G; 3] = [__v_12, __v_13, __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 __ret: [G; OUT_379] = [__v_11, __v_14];
-        record.function_queries[379].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_380: usize = 4;
-const IN_380: usize = 4;
-const OUT_380: usize = 2;
-fn aiur_fn_380(
-  inp: [G; IN_380],
+const INPUT_SIZE_295: usize = 2;
+const IN_295: usize = 2;
+const OUT_295: usize = 1;
+fn aiur_fn_295(
+  inp: [G; IN_295],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_380], ExecError> {
+) -> Result<[G; OUT_295], 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_381] = { let __args: [G; IN_381] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[381].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_381] = unsafe { *(result.output.as_ptr() as *const [G; OUT_381]) }; __ret } else { aiur_fn_381(__args, record, io_buffer, __cu)? } };
-    let __v_4: G = __r_arr[0];
-    let __v_5: G = __r_arr[1];
-    match __v_4.as_canonical_u64() {
+    let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[270].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_270] = unsafe { *(result.output.as_ptr() as *const [G; OUT_270]) }; __ret } else { aiur_fn_270(__args, record, io_buffer, __cu)? } };
+    let __v_2: G = __r_arr[0];
+    match __v_2.as_canonical_u64() {
       1u64 => {
-        let __v_6: G = G::from_u64(1);
-        let __ret: [G; OUT_380] = [__v_6, __v_5];
-        record.function_queries[380].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __v_3: G = G::from_u64(1);
+        let __ret: [G; OUT_295] = [__v_3];
+        record.function_queries[295].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } };
-        let __v_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_381] = { let __args: [G; IN_381] = [__v_6, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[381].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_381] = unsafe { *(result.output.as_ptr() as *const [G; OUT_381]) }; __ret } else { aiur_fn_381(__args, record, io_buffer, __cu)? } };
-        let __v_7: G = __r_arr[0];
-        let __v_8: G = __r_arr[1];
-        let __ret: [G; OUT_380] = [__v_7, __v_8];
-        record.function_queries[380].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[293].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_293] = unsafe { *(result.output.as_ptr() as *const [G; OUT_293]) }; __ret } else { aiur_fn_293(__args, record, io_buffer, __cu)? } };
+        let __v_3: G = __r_arr[0];
+        let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[293].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_293] = unsafe { *(result.output.as_ptr() as *const [G; OUT_293]) }; __ret } else { aiur_fn_293(__args, record, io_buffer, __cu)? } };
+        let __v_4: G = __r_arr[0];
+        let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } else { aiur_fn_286(__args, record, io_buffer, __cu)? } };
+        let __v_5: G = __r_arr[0];
+        let __ret: [G; OUT_295] = [__v_5];
+        record.function_queries[295].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_381: usize = 2;
-const IN_381: usize = 2;
-const OUT_381: usize = 2;
-fn aiur_fn_381(
-  inp: [G; IN_381],
+const INPUT_SIZE_296: usize = 2;
+const IN_296: usize = 2;
+const OUT_296: usize = 1;
+fn aiur_fn_296(
+  inp: [G; IN_296],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_381], ExecError> {
+) -> Result<[G; OUT_296], 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];
+    let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[301].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_301] = unsafe { *(result.output.as_ptr() as *const [G; OUT_301]) }; __ret } else { aiur_fn_301(__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() {
-      3u64 => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; 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: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].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];
-        match __v_6.as_canonical_u64() {
-          2u64 => {
-            let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_1, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-            let __v_10: G = __r_arr[0];
-            let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } else { aiur_fn_295(__args, record, io_buffer, __cu)? } };
-            let __v_11: G = __r_arr[0];
-            let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_12: G = __r_arr[0];
-            match __v_12.as_canonical_u64() {
-              0u64 => {
-                let __v_13: G = G::from_u64(0);
-                let __v_14: G = G::from_u64(0);
-                let __ret: [G; OUT_381] = [__v_13, __v_14];
-                record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+      1u64 => {
+        let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[301].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_301] = unsafe { *(result.output.as_ptr() as *const [G; OUT_301]) }; __ret } else { aiur_fn_301(__args, record, io_buffer, __cu)? } };
+        let __v_4: G = __r_arr[0];
+        let __v_5: G = __r_arr[1];
+        match __v_4.as_canonical_u64() {
+          1u64 => {
+            let __v_6: G = { let __a_val = __v_3.as_canonical_u64(); let __b_val = __v_5.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_6.as_canonical_u64() {
+              1u64 => {
+                let __ret: [G; OUT_296] = [__v_1];
+                record.function_queries[296].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
-              1u64 => {
-                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_13: G = __loaded[0];
-                let __v_14: G = __loaded[1];
-                let __v_15: G = __loaded[2];
-                let __v_16: G = __loaded[3];
-                match __v_13.as_canonical_u64() {
-                  7u64 => {
-                    match __v_14.as_canonical_u64() {
-                      0u64 => {
-                        let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[382].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_382] = unsafe { *(result.output.as_ptr() as *const [G; OUT_382]) }; __ret } else { aiur_fn_382(__args, record, io_buffer, __cu)? } };
-                        let __v_17: G = __r_arr[0];
-                        let __v_18: G = __r_arr[1];
-                        let __ret: [G; OUT_381] = [__v_17, __v_18];
-                        record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                        return Ok(__ret);
-                      },
-                      _ => {
-                        let __v_17: G = G::from_u64(0);
-                        let __v_18: G = G::from_u64(0);
-                        let __ret: [G; OUT_381] = [__v_17, __v_18];
-                        record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                        return Ok(__ret);
-                      },
-                    }
-                  },
-                  _ => {
-                    let __v_17: G = G::from_u64(0);
-                    let __v_18: G = G::from_u64(0);
-                    let __ret: [G; OUT_381] = [__v_17, __v_18];
-                    record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
-                }
+              0u64 => {
+                let __ret: [G; OUT_296] = [__v_0];
+                record.function_queries[296].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
               },
               _ => {
-                return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64()));
+                return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64()));
               },
             }
           },
           _ => {
-            let __v_10: G = G::from_u64(0);
-            let __v_11: G = G::from_u64(0);
-            let __ret: [G; OUT_381] = [__v_10, __v_11];
-            record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } else { aiur_fn_297(__args, record, io_buffer, __cu)? } };
+            let __v_6: G = __r_arr[0];
+            let __ret: [G; OUT_296] = [__v_6];
+            record.function_queries[296].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(0);
-        let __ret: [G; OUT_381] = [__v_6, __v_7];
-        record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } else { aiur_fn_297(__args, record, io_buffer, __cu)? } };
+        let __v_4: G = __r_arr[0];
+        let __ret: [G; OUT_296] = [__v_4];
+        record.function_queries[296].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_382: usize = 1;
-const IN_382: usize = 1;
-const OUT_382: usize = 2;
-fn aiur_fn_382(
-  inp: [G; IN_382],
+const INPUT_SIZE_297: usize = 2;
+const IN_297: usize = 2;
+const OUT_297: usize = 1;
+fn aiur_fn_297(
+  inp: [G; IN_297],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_382], ExecError> {
+) -> Result<[G; OUT_297], 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 };
-    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];
-    match __v_1.as_canonical_u64() {
+    let __v_1: G = inp[1];
+    let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } else { aiur_fn_298(__args, record, io_buffer, __cu)? } };
+    let __v_2: G = __r_arr[0];
+    match __v_2.as_canonical_u64() {
+      1u64 => {
+        let __ret: [G; OUT_297] = [__v_0];
+        record.function_queries[297].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_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: 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 __v_21: G = (__v_8 + __v_9);
-            let __v_22: G = (__v_7 + __v_21);
-            let __v_23: G = (__v_6 + __v_22);
-            let __v_24: G = (__v_5 + __v_23);
-            let __v_25: G = G::from_bool((__v_24 == G::ZERO));
-            match __v_25.as_canonical_u64() {
+        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() {
+          0u64 => {
+            let __ret: [G; OUT_297] = [__v_1];
+            record.function_queries[297].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_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_26: G = G::from_u64(0);
-                let __v_27: G = G::from_u64(0);
-                let __ret: [G; OUT_382] = [__v_26, __v_27];
-                record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_297] = [__v_0];
+                record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
-              1u64 => {
-                let __v_26: G = G::from_u64(256);
-                let __v_27: G = (__v_3 * __v_26);
-                let __v_28: G = G::from_u64(65536);
-                let __v_29: G = (__v_4 * __v_28);
-                let __v_30: G = (__v_27 + __v_29);
-                let __v_31: G = (__v_2 + __v_30);
-                let __v_32: G = G::from_u64(55296);
-                let __v_33: G = { let __a_val = __v_31.as_canonical_u64(); let __b_val = __v_32.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_33.as_canonical_u64() {
+              _ => {
+                let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_1, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[299].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_299] = unsafe { *(result.output.as_ptr() as *const [G; OUT_299]) }; __ret } else { aiur_fn_299(__args, record, io_buffer, __cu)? } };
+                let __v_9: G = __r_arr[0];
+                match __v_9.as_canonical_u64() {
                   1u64 => {
-                    let __v_34: G = G::from_u64(1);
-                    let __ret: [G; OUT_382] = [__v_34, __v_31];
-                    record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_297] = [__v_1];
+                    record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   0u64 => {
-                    let __v_34: G = G::from_u64(57343);
-                    let __v_35: G = { let __a_val = __v_34.as_canonical_u64(); let __b_val = __v_31.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_35.as_canonical_u64() {
-                      0u64 => {
-                        let __v_36: G = G::from_u64(0);
-                        let __v_37: G = G::from_u64(0);
-                        let __ret: [G; OUT_382] = [__v_36, __v_37];
-                        record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[299].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_299] = unsafe { *(result.output.as_ptr() as *const [G; OUT_299]) }; __ret } else { aiur_fn_299(__args, record, io_buffer, __cu)? } };
+                    let __v_10: G = __r_arr[0];
+                    match __v_10.as_canonical_u64() {
+                      1u64 => {
+                        let __ret: [G; OUT_297] = [__v_0];
+                        record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
-                      1u64 => {
-                        let __v_36: G = G::from_u64(1114112);
-                        let __v_37: G = { let __a_val = __v_31.as_canonical_u64(); let __b_val = __v_36.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_37.as_canonical_u64() {
-                          1u64 => {
-                            let __v_38: G = G::from_u64(1);
-                            let __ret: [G; OUT_382] = [__v_38, __v_31];
-                            record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                            return Ok(__ret);
-                          },
-                          0u64 => {
-                            let __v_38: G = G::from_u64(0);
-                            let __v_39: G = G::from_u64(0);
-                            let __ret: [G; OUT_382] = [__v_38, __v_39];
-                            record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                            return Ok(__ret);
-                          },
-                          _ => {
-                            return Err(ExecError::MatchNoCase(__v_37.as_canonical_u64()));
-                          },
-                        }
+                      0u64 => {
+                        let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[300].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_300] = unsafe { *(result.output.as_ptr() as *const [G; OUT_300]) }; __ret } else { aiur_fn_300(__args, record, io_buffer, __cu)? } };
+                        let __v_11: G = __r_arr[0];
+                        let __ret: [G; OUT_297] = [__v_11];
+                        record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        return Ok(__ret);
                       },
                       _ => {
-                        return Err(ExecError::MatchNoCase(__v_35.as_canonical_u64()));
+                        return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64()));
                       },
                     }
                   },
                   _ => {
-                    return Err(ExecError::MatchNoCase(__v_33.as_canonical_u64()));
+                    return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64()));
                   },
                 }
               },
-              _ => {
-                return Err(ExecError::MatchNoCase(__v_25.as_canonical_u64()));
-              },
             }
           },
-          _ => {
-            let __v_21: G = G::from_u64(0);
-            let __v_22: G = G::from_u64(0);
-            let __ret: [G; OUT_382] = [__v_21, __v_22];
-            record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
         }
-      },
-      _ => {
-        let __v_11: G = G::from_u64(0);
-        let __v_12: G = G::from_u64(0);
-        let __ret: [G; OUT_382] = [__v_11, __v_12];
-        record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_383: usize = 2;
-const IN_383: usize = 2;
-const OUT_383: usize = 2;
-fn aiur_fn_383(
-  inp: [G; IN_383],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_383], 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(64);
-    let __v_3: G = { let __a_val = __v_0.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_3.as_canonical_u64() {
-      1u64 => {
-        let __ret: [G; OUT_383] = [__v_0, __v_1];
-        record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __v_4: G = G::from_u64(64);
-        let __v_5: G = (__v_0 - __v_4);
-        let __v_6: G = G::from_u64(1);
-        let __v_7: G = (__v_1 + __v_6);
-        let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } };
-        let __v_8: G = __r_arr[0];
-        let __v_9: G = __r_arr[1];
-        let __ret: [G; OUT_383] = [__v_8, __v_9];
-        record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_384: usize = 1;
-const IN_384: usize = 1;
-const OUT_384: usize = 4;
-fn aiur_fn_384(
-  inp: [G; IN_384],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_384], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = G::from_u64(0);
-    let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__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(0);
-    let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__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(0);
-    let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } };
-    let __v_8: G = __r_arr[0];
-    let __v_9: G = __r_arr[1];
-    let __ret: [G; OUT_384] = [__v_2, __v_5, __v_8, __v_9];
-    record.function_queries[384].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
   })
 }
 
-const INPUT_SIZE_385: usize = 2;
-const IN_385: usize = 2;
-const OUT_385: usize = 1;
-fn aiur_fn_385(
-  inp: [G; IN_385],
+const INPUT_SIZE_298: usize = 2;
+const IN_298: usize = 2;
+const OUT_298: usize = 1;
+fn aiur_fn_298(
+  inp: [G; IN_298],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_385], ExecError> {
+) -> Result<[G; OUT_298], 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_384] = { let __args: [G; IN_384] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__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 = G::from_u64(0);
-    let __v_7: G = if unconstrained { Bytes2::xor(&__v_2, &__v_6) } else { bytes2_xor_value(__v_2, __v_6, record) };
-    let __v_8: G = G::from_u64(0);
-    let __v_9: G = if unconstrained { Bytes2::xor(&__v_3, &__v_8) } else { bytes2_xor_value(__v_3, __v_8, record) };
-    let __v_10: G = G::from_u64(0);
-    let __v_11: G = if unconstrained { Bytes2::xor(&__v_4, &__v_10) } else { bytes2_xor_value(__v_4, __v_10, record) };
-    let __v_12: G = G::from_u64(0);
-    let __v_13: G = if unconstrained { Bytes2::xor(&__v_5, &__v_12) } else { bytes2_xor_value(__v_5, __v_12, record) };
-    let __v_14: G = G::from_u64(64);
-    let __v_15: G = { let __a_val = __v_7.as_canonical_u64(); let __b_val = __v_14.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_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() });
-    }
-    let __v_17: G = G::from_u64(64);
-    let __v_18: G = { let __a_val = __v_9.as_canonical_u64(); let __b_val = __v_17.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_19: G = G::from_u64(1);
-    if (__v_18 != __v_19) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_18.as_canonical_u64(), rhs: __v_19.as_canonical_u64() });
-    }
-    let __v_20: G = G::from_u64(64);
-    let __v_21: G = { let __a_val = __v_11.as_canonical_u64(); let __b_val = __v_20.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_22: G = G::from_u64(1);
-    if (__v_21 != __v_22) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_21.as_canonical_u64(), rhs: __v_22.as_canonical_u64() });
-    }
-    let __v_23: G = G::from_u64(64);
-    let __v_24: G = { let __a_val = __v_13.as_canonical_u64(); let __b_val = __v_23.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_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() });
-    }
-    let __v_26: G = G::from_u64(64);
-    let __v_27: G = (__v_9 * __v_26);
-    let __v_28: G = G::from_u64(4096);
-    let __v_29: G = (__v_11 * __v_28);
-    let __v_30: G = G::from_u64(262144);
-    let __v_31: G = (__v_13 * __v_30);
-    let __v_32: G = (__v_29 + __v_31);
-    let __v_33: G = (__v_27 + __v_32);
-    let __v_34: G = (__v_7 + __v_33);
-    if (__v_0 != __v_34) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_0.as_canonical_u64(), rhs: __v_34.as_canonical_u64() });
-    }
-    let __v_35: G = G::from_u64(128);
-    let __v_36: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_35.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_36.as_canonical_u64() {
-      1u64 => {
-        let __v_37: G = G::from_u64(0);
-        let __v_38: G = { let __values: [G; 3] = [__v_37, __v_0, __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_385] = [__v_38];
-        record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __v_2: G = (__v_0 - __v_1);
+    match __v_2.as_canonical_u64() {
+      0u64 => {
+        let __v_3: G = G::from_u64(1);
+        let __ret: [G; OUT_298] = [__v_3];
+        record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __v_37: G = G::from_u64(2048);
-        let __v_38: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_37.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_38.as_canonical_u64() {
-          1u64 => {
-            let __v_39: G = G::from_u64(128);
-            let __v_40: G = (__v_7 + __v_39);
-            let __v_41: G = G::from_u64(192);
-            let __v_42: G = (__v_9 + __v_41);
-            let __v_43: G = G::from_u64(0);
-            let __v_44: G = G::from_u64(0);
-            let __v_45: G = { let __values: [G; 3] = [__v_44, __v_40, __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 __v_46: G = { let __values: [G; 3] = [__v_43, __v_42, __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 __ret: [G; OUT_385] = [__v_46];
-            record.function_queries[385].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_3: G = __loaded[0];
+        let __v_4: G = __loaded[1];
+        let __v_5: G = __loaded[2];
+        match __v_3.as_canonical_u64() {
           0u64 => {
-            let __v_39: G = G::from_u64(65536);
-            let __v_40: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_39.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_40.as_canonical_u64() {
+            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 = G::from_u64(1);
+                let __ret: [G; OUT_298] = [__v_9];
+                record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                let __v_9: G = G::from_u64(0);
+                let __ret: [G; OUT_298] = [__v_9];
+                record.function_queries[298].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_6: G = __loaded[0];
+            let __v_7: G = __loaded[1];
+            let __v_8: G = __loaded[2];
+            match __v_6.as_canonical_u64() {
               1u64 => {
-                let __v_41: G = G::from_u64(128);
-                let __v_42: G = (__v_7 + __v_41);
-                let __v_43: G = G::from_u64(128);
-                let __v_44: G = (__v_9 + __v_43);
-                let __v_45: G = G::from_u64(224);
-                let __v_46: G = (__v_11 + __v_45);
-                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; 3] = [__v_49, __v_42, __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 __v_51: G = { let __values: [G; 3] = [__v_48, __v_44, __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_47, __v_46, __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 __ret: [G; OUT_385] = [__v_52];
-                record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } else { aiur_fn_298(__args, record, io_buffer, __cu)? } };
+                let __v_9: G = __r_arr[0];
+                let __ret: [G; OUT_298] = [__v_9];
+                record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
-              0u64 => {
-                let __v_41: G = G::from_u64(128);
-                let __v_42: G = (__v_7 + __v_41);
-                let __v_43: G = G::from_u64(128);
-                let __v_44: G = (__v_9 + __v_43);
-                let __v_45: G = G::from_u64(128);
-                let __v_46: G = (__v_11 + __v_45);
-                let __v_47: G = G::from_u64(240);
-                let __v_48: G = (__v_13 + __v_47);
-                let __v_49: G = G::from_u64(0);
-                let __v_50: G = G::from_u64(0);
-                let __v_51: G = G::from_u64(0);
-                let __v_52: G = G::from_u64(0);
-                let __v_53: G = { let __values: [G; 3] = [__v_52, __v_42, __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 __v_54: G = { let __values: [G; 3] = [__v_51, __v_44, __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_50, __v_46, __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 = { let __values: [G; 3] = [__v_49, __v_48, __v_55]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_385] = [__v_56];
-                record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+              _ => {
+                let __v_9: G = G::from_u64(0);
+                let __ret: [G; OUT_298] = [__v_9];
+                record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+            }
+          },
+          2u64 => {
+            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() {
+              2u64 => {
+                let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } else { aiur_fn_298(__args, record, io_buffer, __cu)? } };
+                let __v_9: G = __r_arr[0];
+                let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } else { aiur_fn_298(__args, record, io_buffer, __cu)? } };
+                let __v_10: G = __r_arr[0];
+                let __v_11: G = (__v_9 * __v_10);
+                let __ret: [G; OUT_298] = [__v_11];
+                record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                let __v_9: G = G::from_u64(0);
+                let __ret: [G; OUT_298] = [__v_9];
+                record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+            }
+          },
+          3u64 => {
+            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() {
+              3u64 => {
+                let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } else { aiur_fn_298(__args, record, io_buffer, __cu)? } };
+                let __v_9: G = __r_arr[0];
+                let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } else { aiur_fn_298(__args, record, io_buffer, __cu)? } };
+                let __v_10: G = __r_arr[0];
+                let __v_11: G = (__v_9 * __v_10);
+                let __ret: [G; OUT_298] = [__v_11];
+                record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                let __v_9: G = G::from_u64(0);
+                let __ret: [G; OUT_298] = [__v_9];
+                record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
+            }
+          },
+          4u64 => {
+            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() {
+              4u64 => {
+                let __v_9: G = (__v_4 - __v_7);
+                match __v_9.as_canonical_u64() {
+                  0u64 => {
+                    let __v_10: G = G::from_u64(1);
+                    let __ret: [G; OUT_298] = [__v_10];
+                    record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
+                  },
+                  _ => {
+                    let __v_10: G = G::from_u64(0);
+                    let __ret: [G; OUT_298] = [__v_10];
+                    record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
+                  },
+                }
+              },
               _ => {
-                return Err(ExecError::MatchNoCase(__v_40.as_canonical_u64()));
+                let __v_9: G = G::from_u64(0);
+                let __ret: [G; OUT_298] = [__v_9];
+                record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
               },
             }
           },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_38.as_canonical_u64()));
+            return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_36.as_canonical_u64()));
-      },
     }
   })
 }
 
-const INPUT_SIZE_386: usize = 2;
-const IN_386: usize = 2;
-const OUT_386: usize = 2;
-fn aiur_fn_386(
-  inp: [G; IN_386],
+const INPUT_SIZE_299: usize = 2;
+const IN_299: usize = 2;
+const OUT_299: usize = 1;
+fn aiur_fn_299(
+  inp: [G; IN_299],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_386], ExecError> {
+) -> Result<[G; OUT_299], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -35932,227 +28077,158 @@ fn aiur_fn_386(
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
-      1u64 => {
-        let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } else { aiur_fn_294(__args, record, io_buffer, __cu)? } };
+      2u64 => {
+        let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } else { aiur_fn_298(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
-        let __v_6: G = G::from_u64(0);
-        let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_5, __v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } else { aiur_fn_334(__args, record, io_buffer, __cu)? } };
-        let __v_7: G = __r_arr[0];
-        let __v_8: G = __r_arr[1];
-        match __v_7.as_canonical_u64() {
+        match __v_5.as_canonical_u64() {
           1u64 => {
-            let __v_9: G = G::from_u64(1);
-            let __v_10: G = G::from_u64(2);
-            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 __v_14: G = G::from_u64(0);
-            let __v_15: G = { let __values: [G; 4] = [__v_10, __v_8, __v_13, __v_14]; 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_386] = [__v_9, __v_15];
-            record.function_queries[386].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __v_6: G = G::from_u64(1);
+            let __ret: [G; OUT_299] = [__v_6];
+            record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            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 = { let __values: [G; 4] = [__v_10, __v_11, __v_12, __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_386] = [__v_9, __v_13];
-            record.function_queries[386].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } else { aiur_fn_298(__args, record, io_buffer, __cu)? } };
+            let __v_6: G = __r_arr[0];
+            let __ret: [G; OUT_299] = [__v_6];
+            record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64()));
+            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
           },
         }
       },
       _ => {
         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; 4] = [__v_6, __v_7, __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_386] = [__v_5, __v_9];
-        record.function_queries[386].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_299] = [__v_5];
+        record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_387: usize = 2;
-const IN_387: usize = 2;
-const OUT_387: usize = 2;
-fn aiur_fn_387(
-  inp: [G; IN_387],
+const INPUT_SIZE_300: usize = 2;
+const IN_300: usize = 2;
+const OUT_300: usize = 1;
+fn aiur_fn_300(
+  inp: [G; IN_300],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_387], ExecError> {
+) -> Result<[G; OUT_300], 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_295] = { let __args: [G; IN_295] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } else { aiur_fn_295(__args, record, io_buffer, __cu)? } };
-    let __v_2: G = __r_arr[0];
-    let __v_3: G = G::from_u64(0);
-    let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_2, __v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } else { aiur_fn_334(__args, record, io_buffer, __cu)? } };
-    let __v_4: G = __r_arr[0];
-    let __v_5: G = __r_arr[1];
-    match __v_4.as_canonical_u64() {
-      0u64 => {
-        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 = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_9]; 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_387] = [__v_6, __v_10];
-        record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
+    let __v_2: G = G::from_u64(0);
+    let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[302].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_302] = unsafe { *(result.output.as_ptr() as *const [G; OUT_302]) }; __ret } else { aiur_fn_302(__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(0);
+    let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[302].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_302] = unsafe { *(result.output.as_ptr() as *const [G; OUT_302]) }; __ret } else { aiur_fn_302(__args, record, io_buffer, __cu)? } };
+    let __v_6: G = __r_arr[0];
+    let __v_7: G = __r_arr[1];
+    let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } else { aiur_fn_298(__args, record, io_buffer, __cu)? } };
+    let __v_8: G = __r_arr[0];
+    match __v_8.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_390] = { let __args: [G; IN_390] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[390].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_390] = unsafe { *(result.output.as_ptr() as *const [G; OUT_390]) }; __ret } else { aiur_fn_390(__args, record, io_buffer, __cu)? } };
-        let __v_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_389] = { let __args: [G; IN_389] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[389].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_389] = unsafe { *(result.output.as_ptr() as *const [G; OUT_389]) }; __ret } else { aiur_fn_389(__args, record, io_buffer, __cu)? } };
-        let __v_7: G = __r_arr[0];
-        let __v_8: G = G::from_u64(7);
-        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_7, __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 __v_12: G = G::from_u64(2);
-        let __v_13: G = G::from_u64(1);
-        let __v_14: G = G::from_u64(1);
-        let __v_15: G = { let __values: [G; 3] = [__v_13, __v_14, __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 __v_16: G = G::from_u64(0);
-        let __v_17: G = { let __values: [G; 4] = [__v_12, __v_5, __v_15, __v_16]; 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_18: G = G::from_u64(1);
-        let __v_19: G = G::from_u64(3);
-        let __v_20: G = G::from_u64(0);
-        let __v_21: G = { let __values: [G; 4] = [__v_19, __v_17, __v_11, __v_20]; 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_387] = [__v_18, __v_21];
-        record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __v_9: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_7.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_9.as_canonical_u64() {
+          1u64 => {
+            let __ret: [G; OUT_300] = [__v_1];
+            record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          0u64 => {
+            let __ret: [G; OUT_300] = [__v_0];
+            record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64()));
+          },
+        }
+      },
+      0u64 => {
+        let __v_9: G = G::from_u64(2);
+        let __v_10: G = { let __values: [G; 3] = [__v_9, __v_0, __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_300] = [__v_10];
+        record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
+        return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_388: usize = 1;
-const IN_388: usize = 1;
-const OUT_388: usize = 4;
-fn aiur_fn_388(
-  inp: [G; IN_388],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_388], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = G::from_u64(0);
-    let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[313].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_313] = unsafe { *(result.output.as_ptr() as *const [G; OUT_313]) }; __ret } else { aiur_fn_313(__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(0);
-    let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[313].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_313] = unsafe { *(result.output.as_ptr() as *const [G; OUT_313]) }; __ret } else { aiur_fn_313(__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(0);
-    let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[313].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_313] = unsafe { *(result.output.as_ptr() as *const [G; OUT_313]) }; __ret } else { aiur_fn_313(__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 __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[313].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_313] = unsafe { *(result.output.as_ptr() as *const [G; OUT_313]) }; __ret } else { aiur_fn_313(__args, record, io_buffer, __cu)? } };
-    let __v_11: G = __r_arr[0];
-    let __v_12: G = __r_arr[1];
-    let __ret: [G; OUT_388] = [__v_2, __v_5, __v_8, __v_11];
-    record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_389: usize = 1;
-const IN_389: usize = 1;
-const OUT_389: usize = 1;
-fn aiur_fn_389(
-  inp: [G; IN_389],
+const INPUT_SIZE_301: usize = 1;
+const IN_301: usize = 1;
+const OUT_301: usize = 2;
+fn aiur_fn_301(
+  inp: [G; IN_301],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_389], ExecError> {
+) -> Result<[G; OUT_301], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[388].get_mut(&__args[..]) { let __ret: [G; OUT_388] = unsafe { *(result.output.as_ptr() as *const [G; OUT_388]) }; __ret } else { aiur_fn_388(__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 = G::from_u64(0);
-    let __v_6: G = if unconstrained { Bytes2::xor(&__v_1, &__v_5) } else { bytes2_xor_value(__v_1, __v_5, record) };
-    let __v_7: G = G::from_u64(0);
-    let __v_8: G = if unconstrained { Bytes2::xor(&__v_2, &__v_7) } else { bytes2_xor_value(__v_2, __v_7, record) };
-    let __v_9: G = G::from_u64(0);
-    let __v_10: G = if unconstrained { Bytes2::xor(&__v_3, &__v_9) } else { bytes2_xor_value(__v_3, __v_9, record) };
-    let __v_11: G = G::from_u64(0);
-    let __v_12: G = if unconstrained { Bytes2::xor(&__v_4, &__v_11) } else { bytes2_xor_value(__v_4, __v_11, record) };
-    let __v_13: G = G::from_u64(256);
-    let __v_14: G = (__v_13 * __v_8);
-    let __v_15: G = G::from_u64(65536);
-    let __v_16: G = (__v_15 * __v_10);
-    let __v_17: G = G::from_u64(16777216);
-    let __v_18: G = (__v_17 * __v_12);
-    let __v_19: G = (__v_16 + __v_18);
-    let __v_20: G = (__v_14 + __v_19);
-    let __v_21: G = (__v_6 + __v_20);
-    if (__v_0 != __v_21) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_0.as_canonical_u64(), rhs: __v_21.as_canonical_u64() });
+    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_4: G = G::from_u64(1);
+        let __v_5: G = G::from_u64(0);
+        let __ret: [G; OUT_301] = [__v_4, __v_5];
+        record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      1u64 => {
+        let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[301].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_301] = unsafe { *(result.output.as_ptr() as *const [G; OUT_301]) }; __ret } else { aiur_fn_301(__args, record, io_buffer, __cu)? } };
+        let __v_4: G = __r_arr[0];
+        let __v_5: G = __r_arr[1];
+        match __v_4.as_canonical_u64() {
+          1u64 => {
+            let __v_6: G = G::from_u64(1);
+            let __v_7: G = G::from_u64(1);
+            let __v_8: G = (__v_5 + __v_7);
+            let __ret: [G; OUT_301] = [__v_6, __v_8];
+            record.function_queries[301].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(0);
+            let __ret: [G; OUT_301] = [__v_6, __v_7];
+            record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+        }
+      },
+      _ => {
+        let __v_4: G = G::from_u64(0);
+        let __v_5: G = G::from_u64(0);
+        let __ret: [G; OUT_301] = [__v_4, __v_5];
+        record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
     }
-    let __v_22: G = G::from_u64(0);
-    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 __v_26: G = G::from_u64(0);
-    let __v_27: G = G::from_u64(1);
-    let __v_28: G = G::from_u64(1);
-    let __v_29: G = { let __values: [G; 10] = [__v_27, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28]; 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_30: G = { let __values: [G; 10] = [__v_22, __v_6, __v_8, __v_10, __v_12, __v_23, __v_24, __v_25, __v_26, __v_29]; 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_389] = [__v_30];
-    record.function_queries[389].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_390: usize = 1;
-const IN_390: usize = 1;
-const OUT_390: usize = 1;
-fn aiur_fn_390(
-  inp: [G; IN_390],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_390], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = G::from_u64(65);
-    let __r_arr: [G; OUT_391] = { let __args: [G; IN_391] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[391].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_391] = unsafe { *(result.output.as_ptr() as *const [G; OUT_391]) }; __ret } else { aiur_fn_391(__args, record, io_buffer, __cu)? } };
-    let __v_2: G = __r_arr[0];
-    let __ret: [G; OUT_390] = [__v_2];
-    record.function_queries[390].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_391: usize = 2;
-const IN_391: usize = 2;
-const OUT_391: usize = 1;
-fn aiur_fn_391(
-  inp: [G; IN_391],
+const INPUT_SIZE_302: usize = 2;
+const IN_302: usize = 2;
+const OUT_302: usize = 2;
+fn aiur_fn_302(
+  inp: [G; IN_302],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_391], ExecError> {
+) -> Result<[G; OUT_302], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -36162,175 +28238,99 @@ fn aiur_fn_391(
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_391] = [__v_1];
-        record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __r_arr: [G; OUT_392] = { let __args: [G; IN_392] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[392].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_392] = unsafe { *(result.output.as_ptr() as *const [G; OUT_392]) }; __ret } else { aiur_fn_392(__args, record, io_buffer, __cu)? } };
-        let __v_5: G = __r_arr[0];
-        let __v_6: G = __r_arr[1];
-        let __r_arr: [G; OUT_391] = { let __args: [G; IN_391] = [__v_6, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[391].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_391] = unsafe { *(result.output.as_ptr() as *const [G; OUT_391]) }; __ret } else { aiur_fn_391(__args, record, io_buffer, __cu)? } };
+        let __v_5: G = G::from_u64(1);
+        let __v_6: G = (__v_1 + __v_5);
+        let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[302].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_302] = unsafe { *(result.output.as_ptr() as *const [G; OUT_302]) }; __ret } else { aiur_fn_302(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_391] = [__v_7];
-        record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __v_8: G = __r_arr[1];
+        let __ret: [G; OUT_302] = [__v_7, __v_8];
+        record.function_queries[302].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+        let __ret: [G; OUT_302] = [__v_0, __v_1];
+        record.function_queries[302].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_392: usize = 2;
-const IN_392: usize = 2;
-const OUT_392: usize = 2;
-fn aiur_fn_392(
-  inp: [G; IN_392],
+const INPUT_SIZE_303: usize = 2;
+const IN_303: usize = 2;
+const OUT_303: usize = 1;
+fn aiur_fn_303(
+  inp: [G; IN_303],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_392], ExecError> {
+) -> Result<[G; OUT_303], 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(128);
-    let __v_3: G = if unconstrained { Bytes2::less_than(&__v_0, &__v_2) } else { bytes2_less_than_value(__v_0, __v_2, record) };
-    match __v_3.as_canonical_u64() {
+    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() {
+      0u64 => {
+        let __v_5: G = G::from_u64(0);
+        let __v_6: G = G::from_u64(0);
+        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_303] = [__v_7];
+        record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
       1u64 => {
-        let __ret: [G; OUT_392] = [__v_0, __v_1];
-        record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[296].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_296] = unsafe { *(result.output.as_ptr() as *const [G; OUT_296]) }; __ret } else { aiur_fn_296(__args, record, io_buffer, __cu)? } };
+        let __v_5: G = __r_arr[0];
+        let __ret: [G; OUT_303] = [__v_5];
+        record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __v_4: G = G::from_u64(224);
-        let __v_5: G = if unconstrained { Bytes2::less_than(&__v_0, &__v_4) } else { bytes2_less_than_value(__v_0, __v_4, record) };
+      _ => {
+        let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } else { aiur_fn_269(__args, record, io_buffer, __cu)? } };
+        let __v_5: G = __r_arr[0];
         match __v_5.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_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 __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[296].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_296] = unsafe { *(result.output.as_ptr() as *const [G; OUT_296]) }; __ret } else { aiur_fn_296(__args, record, io_buffer, __cu)? } };
+            let __v_6: G = __r_arr[0];
+            let __ret: [G; OUT_303] = [__v_6];
+            record.function_queries[303].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_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_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 = G::from_u64(192);
-                let __v_10: G = (__v_0 - __v_9);
-                let __v_11: G = G::from_u64(64);
-                let __v_12: G = (__v_10 * __v_11);
-                let __v_13: G = G::from_u64(128);
-                let __v_14: G = (__v_7 - __v_13);
-                let __v_15: G = (__v_12 + __v_14);
-                let __ret: [G; OUT_392] = [__v_15, __v_8];
-                record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_303] = [__v_1];
+                record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64()));
-              },
-            }
-          },
-          0u64 => {
-            let __v_6: G = G::from_u64(240);
-            let __v_7: G = if unconstrained { Bytes2::less_than(&__v_0, &__v_6) } else { bytes2_less_than_value(__v_0, __v_6, record) };
-            match __v_7.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_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_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 __v_14: G = G::from_u64(224);
-                        let __v_15: G = (__v_0 - __v_14);
-                        let __v_16: G = G::from_u64(4096);
-                        let __v_17: G = (__v_15 * __v_16);
-                        let __v_18: G = G::from_u64(128);
-                        let __v_19: G = (__v_9 - __v_18);
-                        let __v_20: G = G::from_u64(64);
-                        let __v_21: G = (__v_19 * __v_20);
-                        let __v_22: G = G::from_u64(128);
-                        let __v_23: G = (__v_12 - __v_22);
-                        let __v_24: G = (__v_21 + __v_23);
-                        let __v_25: G = (__v_17 + __v_24);
-                        let __ret: [G; OUT_392] = [__v_25, __v_13];
-                        record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                        return Ok(__ret);
-                      },
-                      _ => {
-                        return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64()));
-                      },
-                    }
-                  },
-                  _ => {
-                    return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64()));
+                let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[270].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_270] = unsafe { *(result.output.as_ptr() as *const [G; OUT_270]) }; __ret } else { aiur_fn_270(__args, record, io_buffer, __cu)? } };
+                let __v_9: G = __r_arr[0];
+                match __v_9.as_canonical_u64() {
+                  1u64 => {
+                    let __ret: [G; OUT_303] = [__v_0];
+                    record.function_queries[303].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_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 __v_17: G = G::from_u64(240);
-                            let __v_18: G = (__v_0 - __v_17);
-                            let __v_19: G = G::from_u64(262144);
-                            let __v_20: G = (__v_18 * __v_19);
-                            let __v_21: G = G::from_u64(128);
-                            let __v_22: G = (__v_9 - __v_21);
-                            let __v_23: G = G::from_u64(4096);
-                            let __v_24: G = (__v_22 * __v_23);
-                            let __v_25: G = G::from_u64(128);
-                            let __v_26: G = (__v_12 - __v_25);
-                            let __v_27: G = G::from_u64(64);
-                            let __v_28: G = (__v_26 * __v_27);
-                            let __v_29: G = G::from_u64(128);
-                            let __v_30: G = (__v_15 - __v_29);
-                            let __v_31: G = (__v_28 + __v_30);
-                            let __v_32: G = (__v_24 + __v_31);
-                            let __v_33: G = (__v_20 + __v_32);
-                            let __ret: [G; OUT_392] = [__v_33, __v_16];
-                            record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                            return Ok(__ret);
-                          },
-                          _ => {
-                            return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64()));
-                          },
-                        }
-                      },
-                      _ => {
-                        return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64()));
-                      },
-                    }
+                    let __v_10: G = G::from_u64(3);
+                    let __v_11: G = { let __values: [G; 3] = [__v_10, __v_0, __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_303] = [__v_11];
+                    record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
                   },
                   _ => {
-                    return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64()));
+                    return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64()));
                   },
                 }
               },
-              _ => {
-                return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64()));
-              },
             }
           },
           _ => {
@@ -36338,859 +28338,595 @@ fn aiur_fn_392(
           },
         }
       },
+    }
+  })
+}
+
+const INPUT_SIZE_304: usize = 1;
+const IN_304: usize = 1;
+const OUT_304: usize = 1;
+fn aiur_fn_304(
+  inp: [G; IN_304],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_304], 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 __v_4: G = G::from_u64(0);
+        let __v_5: G = G::from_u64(0);
+        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_304] = [__v_6];
+        record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      4u64 => {
+        let __v_4: G = G::from_u64(4);
+        let __v_5: G = G::from_u64(0);
+        let __v_6: G = { let __values: [G; 3] = [__v_4, __v_2, __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_304] = [__v_6];
+        record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      1u64 => {
+        let __v_4: G = G::from_u64(1);
+        let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[304].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_304] = unsafe { *(result.output.as_ptr() as *const [G; OUT_304]) }; __ret } else { aiur_fn_304(__args, record, io_buffer, __cu)? } };
+        let __v_5: G = __r_arr[0];
+        let __v_6: G = G::from_u64(0);
+        let __v_7: G = { let __values: [G; 3] = [__v_4, __v_5, __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_304] = [__v_7];
+        record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      2u64 => {
+        let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[304].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_304] = unsafe { *(result.output.as_ptr() as *const [G; OUT_304]) }; __ret } else { aiur_fn_304(__args, record, io_buffer, __cu)? } };
+        let __v_4: G = __r_arr[0];
+        let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[304].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_304] = unsafe { *(result.output.as_ptr() as *const [G; OUT_304]) }; __ret } else { aiur_fn_304(__args, record, io_buffer, __cu)? } };
+        let __v_5: G = __r_arr[0];
+        let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[296].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_296] = unsafe { *(result.output.as_ptr() as *const [G; OUT_296]) }; __ret } else { aiur_fn_296(__args, record, io_buffer, __cu)? } };
+        let __v_6: G = __r_arr[0];
+        let __ret: [G; OUT_304] = [__v_6];
+        record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      3u64 => {
+        let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[304].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_304] = unsafe { *(result.output.as_ptr() as *const [G; OUT_304]) }; __ret } else { aiur_fn_304(__args, record, io_buffer, __cu)? } };
+        let __v_4: G = __r_arr[0];
+        let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[304].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_304] = unsafe { *(result.output.as_ptr() as *const [G; OUT_304]) }; __ret } else { aiur_fn_304(__args, record, io_buffer, __cu)? } };
+        let __v_5: G = __r_arr[0];
+        let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[303].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_303] = unsafe { *(result.output.as_ptr() as *const [G; OUT_303]) }; __ret } else { aiur_fn_303(__args, record, io_buffer, __cu)? } };
+        let __v_6: G = __r_arr[0];
+        let __ret: [G; OUT_304] = [__v_6];
+        record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_393: usize = 2;
-const IN_393: usize = 2;
-const OUT_393: usize = 2;
-fn aiur_fn_393(
-  inp: [G; IN_393],
+const INPUT_SIZE_305: usize = 2;
+const IN_305: usize = 2;
+const OUT_305: usize = 1;
+fn aiur_fn_305(
+  inp: [G; IN_305],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_393], ExecError> {
+) -> Result<[G; OUT_305], 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_300] = { let __args: [G; IN_300] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[300].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_300] = unsafe { *(result.output.as_ptr() as *const [G; OUT_300]) }; __ret } else { aiur_fn_300(__args, record, io_buffer, __cu)? } };
-    let __v_2: G = __r_arr[0];
-    let __v_3: G = G::from_u64(0);
-    let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_2, __v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } else { aiur_fn_334(__args, record, io_buffer, __cu)? } };
-    let __v_4: G = __r_arr[0];
-    let __v_5: G = __r_arr[1];
-    match __v_4.as_canonical_u64() {
+    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(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 = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_9]; 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_393] = [__v_6, __v_10];
-        record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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_305] = [__v_7];
+        record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[301].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_301] = unsafe { *(result.output.as_ptr() as *const [G; OUT_301]) }; __ret } else { aiur_fn_301(__args, record, io_buffer, __cu)? } };
+        let __v_5: G = G::from_u64(1);
+        let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = unsafe { *(result.output.as_ptr() as *const [G; OUT_305]) }; __ret } else { aiur_fn_305(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
         let __v_7: G = G::from_u64(0);
-        let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_6, __v_1, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } else { aiur_fn_334(__args, record, io_buffer, __cu)? } };
-        let __v_8: G = __r_arr[0];
-        let __v_9: G = __r_arr[1];
-        match __v_8.as_canonical_u64() {
-          0u64 => {
-            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 = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; 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_393] = [__v_10, __v_14];
-            record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          1u64 => {
-            let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[296].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_296] = unsafe { *(result.output.as_ptr() as *const [G; OUT_296]) }; __ret } else { aiur_fn_296(__args, record, io_buffer, __cu)? } };
-            let __v_10: G = __r_arr[0];
-            let __v_11: G = G::from_u64(0);
-            let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_10, __v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } else { aiur_fn_334(__args, record, io_buffer, __cu)? } };
-            let __v_12: G = __r_arr[0];
-            let __v_13: G = __r_arr[1];
-            match __v_12.as_canonical_u64() {
-              0u64 => {
-                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 = G::from_u64(0);
-                let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; 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_393] = [__v_14, __v_18];
-                record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              1u64 => {
-                let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } else { aiur_fn_295(__args, record, io_buffer, __cu)? } };
-                let __v_14: G = __r_arr[0];
-                let __v_15: G = G::from_u64(0);
-                let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_14, __v_1, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } else { aiur_fn_334(__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() {
-                  0u64 => {
-                    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 = { let __values: [G; 4] = [__v_19, __v_20, __v_21, __v_21]; 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_393] = [__v_18, __v_22];
-                    record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
-                  1u64 => {
-                    let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } else { aiur_fn_297(__args, record, io_buffer, __cu)? } };
-                    let __v_18: G = __r_arr[0];
-                    let __v_19: G = G::from_u64(0);
-                    let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_18, __v_1, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } else { aiur_fn_334(__args, record, io_buffer, __cu)? } };
-                    let __v_20: G = __r_arr[0];
-                    let __v_21: G = __r_arr[1];
-                    match __v_20.as_canonical_u64() {
-                      0u64 => {
-                        let __v_22: G = G::from_u64(0);
-                        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 __v_26: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_25]; 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_393] = [__v_22, __v_26];
-                        record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                        return Ok(__ret);
-                      },
-                      1u64 => {
-                        let __v_22: G = G::from_u64(0);
-                        let __v_23: G = G::from_u64(0);
-                        let __v_24: G = { let __values: [G; 3] = [__v_22, __v_23, __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 __v_25: G = G::from_u64(0);
-                        let __v_26: G = G::from_u64(1);
-                        let __v_27: G = G::from_u64(1);
-                        let __v_28: G = { let __values: [G; 3] = [__v_26, __v_27, __v_27]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                        let __v_29: G = { let __values: [G; 3] = [__v_25, __v_24, __v_28]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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 = G::from_u64(2);
-                        let __v_31: G = G::from_u64(0);
-                        let __v_32: G = { let __values: [G; 4] = [__v_30, __v_5, __v_29, __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 = G::from_u64(2);
-                        let __v_34: G = G::from_u64(0);
-                        let __v_35: G = { let __values: [G; 4] = [__v_33, __v_9, __v_29, __v_34]; 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_36: G = G::from_u64(2);
-                        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 = { let __values: [G; 4] = [__v_36, __v_13, __v_39, __v_40]; 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_42: G = G::from_u64(2);
-                        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 __v_46: G = G::from_u64(0);
-                        let __v_47: G = { let __values: [G; 4] = [__v_42, __v_17, __v_45, __v_46]; 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_48: G = G::from_u64(2);
-                        let __v_49: G = G::from_u64(1);
-                        let __v_50: G = G::from_u64(1);
-                        let __v_51: G = { let __values: [G; 3] = [__v_49, __v_50, __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 = G::from_u64(0);
-                        let __v_53: G = { let __values: [G; 4] = [__v_48, __v_21, __v_51, __v_52]; 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_54: G = G::from_u64(3);
-                        let __v_55: G = G::from_u64(0);
-                        let __v_56: G = { let __values: [G; 4] = [__v_54, __v_32, __v_41, __v_55]; 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_57: G = G::from_u64(3);
-                        let __v_58: G = G::from_u64(0);
-                        let __v_59: G = { let __values: [G; 4] = [__v_57, __v_35, __v_41, __v_58]; 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_394] = { let __args: [G; IN_394] = [__v_0, __v_56, __v_59, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } };
-                        let __v_60: G = __r_arr[0];
-                        let __v_61: G = G::from_u64(1);
-                        let __v_62: G = G::from_u64(3);
-                        let __v_63: G = G::from_u64(0);
-                        let __v_64: G = { let __values: [G; 4] = [__v_62, __v_53, __v_60, __v_63]; 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_393] = [__v_61, __v_64];
-                        record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                        return Ok(__ret);
-                      },
-                      _ => {
-                        return Err(ExecError::MatchNoCase(__v_20.as_canonical_u64()));
-                      },
-                    }
-                  },
-                  _ => {
-                    return Err(ExecError::MatchNoCase(__v_16.as_canonical_u64()));
-                  },
-                }
-              },
-              _ => {
-                return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64()));
-              },
-            }
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64()));
-          },
-        }
+        let __v_8: G = { let __values: [G; 3] = [__v_5, __v_6, __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_305] = [__v_8];
+        record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      2u64 => {
+        let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = unsafe { *(result.output.as_ptr() as *const [G; OUT_305]) }; __ret } else { aiur_fn_305(__args, record, io_buffer, __cu)? } };
+        let __v_5: G = __r_arr[0];
+        let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = unsafe { *(result.output.as_ptr() as *const [G; OUT_305]) }; __ret } else { aiur_fn_305(__args, record, io_buffer, __cu)? } };
+        let __v_6: G = __r_arr[0];
+        let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[296].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_296] = unsafe { *(result.output.as_ptr() as *const [G; OUT_296]) }; __ret } else { aiur_fn_296(__args, record, io_buffer, __cu)? } };
+        let __v_7: G = __r_arr[0];
+        let __ret: [G; OUT_305] = [__v_7];
+        record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      3u64 => {
+        let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = unsafe { *(result.output.as_ptr() as *const [G; OUT_305]) }; __ret } else { aiur_fn_305(__args, record, io_buffer, __cu)? } };
+        let __v_5: G = __r_arr[0];
+        let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = unsafe { *(result.output.as_ptr() as *const [G; OUT_305]) }; __ret } else { aiur_fn_305(__args, record, io_buffer, __cu)? } };
+        let __v_6: G = __r_arr[0];
+        let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[303].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_303] = unsafe { *(result.output.as_ptr() as *const [G; OUT_303]) }; __ret } else { aiur_fn_303(__args, record, io_buffer, __cu)? } };
+        let __v_7: G = __r_arr[0];
+        let __ret: [G; OUT_305] = [__v_7];
+        record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      4u64 => {
+        let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } };
+        let __v_5: G = __r_arr[0];
+        let __ret: [G; OUT_305] = [__v_5];
+        record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_394: usize = 4;
-const IN_394: usize = 4;
-const OUT_394: usize = 1;
-fn aiur_fn_394(
-  inp: [G; IN_394],
+const INPUT_SIZE_306: usize = 2;
+const IN_306: usize = 2;
+const OUT_306: usize = 1;
+fn aiur_fn_306(
+  inp: [G; IN_306],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_394], ExecError> {
+) -> Result<[G; OUT_306], 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_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_4: G = __loaded[0];
-    let __v_5: G = __loaded[1];
-    let __v_6: G = __loaded[2];
-    match __v_4.as_canonical_u64() {
+    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_394] = [__v_1];
-        record.function_queries[394].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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_306] = [__v_7];
+        record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_392] = { let __args: [G; IN_392] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[392].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_392] = unsafe { *(result.output.as_ptr() as *const [G; OUT_392]) }; __ret } else { aiur_fn_392(__args, record, io_buffer, __cu)? } };
+        let __v_5: G = G::from_u64(0);
+        let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = unsafe { *(result.output.as_ptr() as *const [G; OUT_305]) }; __ret } else { aiur_fn_305(__args, record, io_buffer, __cu)? } };
+        let __v_6: G = __r_arr[0];
+        let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } else { aiur_fn_306(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __v_8: G = __r_arr[1];
-        let __r_arr: [G; OUT_389] = { let __args: [G; IN_389] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[389].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_389] = unsafe { *(result.output.as_ptr() as *const [G; OUT_389]) }; __ret } else { aiur_fn_389(__args, record, io_buffer, __cu)? } };
-        let __v_9: G = __r_arr[0];
-        let __v_10: G = G::from_u64(7);
-        let __v_11: G = G::from_u64(0);
-        let __v_12: G = G::from_u64(0);
-        let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_9, __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 __v_14: G = G::from_u64(3);
-        let __v_15: G = G::from_u64(0);
-        let __v_16: G = { let __values: [G; 4] = [__v_14, __v_3, __v_13, __v_15]; 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_17: G = G::from_u64(3);
-        let __v_18: G = G::from_u64(0);
-        let __v_19: G = { let __values: [G; 4] = [__v_17, __v_2, __v_16, __v_18]; 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_394] = { let __args: [G; IN_394] = [__v_8, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } };
-        let __v_20: G = __r_arr[0];
-        let __v_21: G = G::from_u64(3);
-        let __v_22: G = G::from_u64(0);
-        let __v_23: G = { let __values: [G; 4] = [__v_21, __v_19, __v_20, __v_22]; 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_394] = [__v_23];
-        record.function_queries[394].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __v_8: G = { let __values: [G; 3] = [__v_5, __v_6, __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_306] = [__v_8];
+        record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_395: usize = 4;
-const IN_395: usize = 4;
-const OUT_395: usize = 1;
-fn aiur_fn_395(
-  inp: [G; IN_395],
+const INPUT_SIZE_307: usize = 2;
+const IN_307: usize = 2;
+const OUT_307: usize = 1;
+fn aiur_fn_307(
+  inp: [G; IN_307],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_395], ExecError> {
+) -> Result<[G; OUT_307], 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; 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_4: G = __loaded[0];
-    let __v_5: G = __loaded[1];
-    let __v_6: G = __loaded[2];
-    let __v_7: G = __loaded[3];
-    match __v_4.as_canonical_u64() {
-      3u64 => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; 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: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].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];
-        match __v_8.as_canonical_u64() {
-          2u64 => {
-            let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-            let __v_12: G = __r_arr[0];
-            let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr };
-            let __v_13: G = __loaded[0];
-            let __v_14: G = __loaded[1];
-            let __v_15: G = __loaded[2];
-            let __v_16: G = __loaded[3];
-            let __v_17: G = __loaded[4];
-            let __v_18: G = __loaded[5];
-            let __v_19: G = __loaded[6];
-            let __v_20: G = __loaded[7];
-            let __v_21: G = __loaded[8];
-            let __v_22: G = __loaded[9];
-            let __v_23: G = __loaded[10];
-            match __v_13.as_canonical_u64() {
-              1u64 => {
-                let __v_24: G = G::from_u64(1);
-                let __v_25: G = G::from_u64(1);
-                let __v_26: G = { let __values: [G; 3] = [__v_24, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_228] = { let __args: [G; IN_228] = [__v_16, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } };
-                let __v_27: 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_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: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
-                let __v_28: G = __loaded[0];
-                let __v_29: G = __loaded[1];
-                let __v_30: G = __loaded[2];
-                let __v_31: G = __loaded[3];
-                match __v_28.as_canonical_u64() {
-                  4u64 => {
-                    let __v_32: G = G::from_u64(0);
-                    let __r_arr: [G; OUT_419] = { let __args: [G; IN_419] = [__v_30, __v_6, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[419].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_419] = unsafe { *(result.output.as_ptr() as *const [G; OUT_419]) }; __ret } else { aiur_fn_419(__args, record, io_buffer, __cu)? } };
-                    let __v_33: G = __r_arr[0];
-                    let __r_arr: [G; OUT_433] = { let __args: [G; IN_433] = [__v_33, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[433].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_433] = unsafe { *(result.output.as_ptr() as *const [G; OUT_433]) }; __ret } else { aiur_fn_433(__args, record, io_buffer, __cu)? } };
-                    let __v_34: G = __r_arr[0];
-                    let __ret: [G; OUT_395] = [__v_34];
-                    record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
-                  _ => {
-                    let __v_32: G = G::from_u64(3);
-                    let __v_33: G = G::from_u64(0);
-                    let __v_34: G = { let __values: [G; 4] = [__v_32, __v_27, __v_6, __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 __r_arr: [G; OUT_433] = { let __args: [G; IN_433] = [__v_34, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[433].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_433] = unsafe { *(result.output.as_ptr() as *const [G; OUT_433]) }; __ret } else { aiur_fn_433(__args, record, io_buffer, __cu)? } };
-                    let __v_35: G = __r_arr[0];
-                    let __ret: [G; OUT_395] = [__v_35];
-                    record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
-                }
-              },
-              _ => {
-                let __ret: [G; OUT_395] = [__v_0];
-                record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-            }
-          },
-          _ => {
-            let __ret: [G; OUT_395] = [__v_0];
-            record.function_queries[395].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_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_307] = [__v_0];
+        record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
       _ => {
-        let __ret: [G; OUT_395] = [__v_0];
-        record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[308].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_308] = unsafe { *(result.output.as_ptr() as *const [G; OUT_308]) }; __ret } else { aiur_fn_308(__args, record, io_buffer, __cu)? } };
+        let __v_5: G = __r_arr[0];
+        let __ret: [G; OUT_307] = [__v_5];
+        record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_396: usize = 4;
-const IN_396: usize = 4;
-const OUT_396: usize = 1;
-fn aiur_fn_396(
-  inp: [G; IN_396],
+const INPUT_SIZE_308: usize = 2;
+const IN_308: usize = 2;
+const OUT_308: usize = 1;
+fn aiur_fn_308(
+  inp: [G; IN_308],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_396], ExecError> {
+) -> Result<[G; OUT_308], 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; 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_4: G = __loaded[0];
-    let __v_5: G = __loaded[1];
-    let __v_6: G = __loaded[2];
-    let __v_7: G = __loaded[3];
-    match __v_4.as_canonical_u64() {
+    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() {
+      0u64 => {
+        let __v_6: G = G::from_u64(0);
+        let __v_7: G = G::from_u64(0);
+        let __v_8: G = { let __values: [G; 4] = [__v_6, __v_3, __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_308] = [__v_8];
+        record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      1u64 => {
+        let __v_6: G = G::from_u64(1);
+        let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = unsafe { *(result.output.as_ptr() as *const [G; OUT_305]) }; __ret } else { aiur_fn_305(__args, record, io_buffer, __cu)? } };
+        let __v_7: G = __r_arr[0];
+        let __v_8: G = G::from_u64(0);
+        let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __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_308] = [__v_9];
+        record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      2u64 => {
+        let __v_6: G = G::from_u64(2);
+        let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } else { aiur_fn_306(__args, record, io_buffer, __cu)? } };
+        let __v_7: G = __r_arr[0];
+        let __v_8: G = G::from_u64(0);
+        let __v_9: G = { let __values: [G; 4] = [__v_6, __v_3, __v_7, __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_308] = [__v_9];
+        record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      3u64 => {
+        let __v_6: G = G::from_u64(3);
+        let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } else { aiur_fn_307(__args, record, io_buffer, __cu)? } };
+        let __v_7: G = __r_arr[0];
+        let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } else { aiur_fn_307(__args, record, io_buffer, __cu)? } };
+        let __v_8: G = __r_arr[0];
+        let __v_9: G = G::from_u64(0);
+        let __v_10: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_9]; 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_308] = [__v_10];
+        record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      4u64 => {
+        let __v_6: G = G::from_u64(4);
+        let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } else { aiur_fn_307(__args, record, io_buffer, __cu)? } };
+        let __v_7: G = __r_arr[0];
+        let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } else { aiur_fn_307(__args, record, io_buffer, __cu)? } };
+        let __v_8: G = __r_arr[0];
+        let __v_9: G = G::from_u64(0);
+        let __v_10: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_9]; 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_308] = [__v_10];
+        record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      5u64 => {
+        let __v_6: G = G::from_u64(5);
+        let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } else { aiur_fn_307(__args, record, io_buffer, __cu)? } };
+        let __v_7: G = __r_arr[0];
+        let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } else { aiur_fn_307(__args, record, io_buffer, __cu)? } };
+        let __v_8: G = __r_arr[0];
+        let __v_9: G = G::from_u64(0);
+        let __v_10: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_9]; 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_308] = [__v_10];
+        record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      6u64 => {
+        let __v_6: G = G::from_u64(6);
+        let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } else { aiur_fn_307(__args, record, io_buffer, __cu)? } };
+        let __v_7: G = __r_arr[0];
+        let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } else { aiur_fn_307(__args, record, io_buffer, __cu)? } };
+        let __v_8: G = __r_arr[0];
+        let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } else { aiur_fn_307(__args, record, io_buffer, __cu)? } };
+        let __v_9: G = __r_arr[0];
+        let __v_10: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_9]; 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_308] = [__v_10];
+        record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
       7u64 => {
-        match __v_5.as_canonical_u64() {
-          1u64 => {
-            let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_6, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[393].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_393] = unsafe { *(result.output.as_ptr() as *const [G; OUT_393]) }; __ret } else { aiur_fn_393(__args, record, io_buffer, __cu)? } };
-            let __v_8: G = __r_arr[0];
-            let __v_9: G = __r_arr[1];
-            match __v_8.as_canonical_u64() {
-              1u64 => {
-                let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_9, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[395].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_395] = unsafe { *(result.output.as_ptr() as *const [G; OUT_395]) }; __ret } else { aiur_fn_395(__args, record, io_buffer, __cu)? } };
-                let __v_10: G = __r_arr[0];
-                let __ret: [G; OUT_396] = [__v_10];
-                record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              0u64 => {
-                let __ret: [G; OUT_396] = [__v_0];
-                record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              _ => {
-                return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64()));
-              },
-            }
-          },
-          _ => {
-            let __ret: [G; OUT_396] = [__v_0];
-            record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-        }
+        let __v_6: G = G::from_u64(7);
+        let __v_7: G = G::from_u64(0);
+        let __v_8: G = { let __values: [G; 4] = [__v_6, __v_3, __v_4, __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_308] = [__v_8];
+        record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
-      _ => {
-        let __ret: [G; OUT_396] = [__v_0];
-        record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+      8u64 => {
+        let __v_6: G = G::from_u64(8);
+        let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } else { aiur_fn_307(__args, record, io_buffer, __cu)? } };
+        let __v_7: G = __r_arr[0];
+        let __v_8: G = { let __values: [G; 4] = [__v_6, __v_3, __v_4, __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_308] = [__v_8];
+        record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
     }
   })
 }
 
-const INPUT_SIZE_397: usize = 3;
-const IN_397: usize = 3;
-const OUT_397: usize = 2;
-fn aiur_fn_397(
-  inp: [G; IN_397],
+const INPUT_SIZE_309: usize = 2;
+const IN_309: usize = 2;
+const OUT_309: usize = 1;
+fn aiur_fn_309(
+  inp: [G; IN_309],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_397], ExecError> {
+) -> Result<[G; OUT_309], 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_778] = { let __args: [G; IN_778] = [__v_2, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-    let __v_3: G = __r_arr[0];
-    let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr };
-    let __v_4: G = __loaded[0];
-    let __v_5: G = __loaded[1];
-    let __v_6: G = __loaded[2];
-    let __v_7: G = __loaded[3];
-    let __v_8: G = __loaded[4];
-    let __v_9: G = __loaded[5];
-    let __v_10: G = __loaded[6];
-    let __v_11: G = __loaded[7];
-    let __v_12: G = __loaded[8];
-    let __v_13: G = __loaded[9];
-    let __v_14: G = __loaded[10];
-    match __v_4.as_canonical_u64() {
+    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 __v_15: G = G::from_u64(0);
-        let __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__v_7, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[399].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_399] = unsafe { *(result.output.as_ptr() as *const [G; OUT_399]) }; __ret } else { aiur_fn_399(__args, record, io_buffer, __cu)? } };
-        let __v_16: G = __r_arr[0];
-        let __v_17: G = __r_arr[1];
-        let __v_18: G = __r_arr[2];
-        let __v_19: G = __r_arr[3];
-        let __v_20: G = __r_arr[4];
-        match __v_16.as_canonical_u64() {
+        let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; 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: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
+        let __v_12: G = __loaded[0];
+        let __v_13: G = __loaded[1];
+        let __v_14: G = __loaded[2];
+        let __v_15: G = __loaded[3];
+        let __v_16: G = __loaded[4];
+        let __v_17: G = __loaded[5];
+        let __v_18: G = __loaded[6];
+        let __v_19: G = __loaded[7];
+        let __v_20: G = __loaded[8];
+        let __v_21: G = __loaded[9];
+        match __v_12.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { 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_21: G = __r_arr[0];
-            let __v_22: G = { let __a_val = __v_21.as_canonical_u64(); let __b_val = __v_17.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_22: G = G::from_u64(1);
+            let __ret: [G; OUT_309] = [__v_22];
+            record.function_queries[309].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            let __v_22: G = G::from_u64(0);
+            let __ret: [G; OUT_309] = [__v_22];
+            record.function_queries[309].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_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: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
+        let __v_12: G = __loaded[0];
+        let __v_13: G = __loaded[1];
+        let __v_14: G = __loaded[2];
+        let __v_15: G = __loaded[3];
+        let __v_16: G = __loaded[4];
+        let __v_17: G = __loaded[5];
+        let __v_18: G = __loaded[6];
+        let __v_19: G = __loaded[7];
+        let __v_20: G = __loaded[8];
+        let __v_21: G = __loaded[9];
+        match __v_12.as_canonical_u64() {
+          1u64 => {
+            let __v_22: G = G::from_u64(0);
+            let __ret: [G; OUT_309] = [__v_22];
+            record.function_queries[309].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          0u64 => {
+            let __r_arr: [G; OUT_11] = { let __args: [G; IN_11] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[11].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_11] = unsafe { *(result.output.as_ptr() as *const [G; OUT_11]) }; __ret } else { aiur_fn_11(__args, record, io_buffer, __cu)? } };
+            let __v_22: G = __r_arr[0];
             match __v_22.as_canonical_u64() {
               1u64 => {
-                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 __v_26: G = G::from_u64(0);
-                let __v_27: G = { let __values: [G; 4] = [__v_24, __v_25, __v_26, __v_26]; 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_397] = [__v_23, __v_27];
-                record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } };
+                let __v_23: G = __r_arr[0];
+                let __ret: [G; OUT_309] = [__v_23];
+                record.function_queries[309].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               0u64 => {
-                let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_1, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-                let __v_23: G = __r_arr[0];
-                let __v_24: G = G::from_u64(8);
-                let __v_25: G = { let __values: [G; 4] = [__v_24, __v_18, __v_19, __v_23]; 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_796] = { let __args: [G; IN_796] = [__v_1, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[796].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_796] = unsafe { *(result.output.as_ptr() as *const [G; OUT_796]) }; __ret } else { aiur_fn_796(__args, record, io_buffer, __cu)? } };
-                let __v_26: G = __r_arr[0];
-                let __v_27: G = G::from_u64(1);
-                let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[427].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_427] = unsafe { *(result.output.as_ptr() as *const [G; OUT_427]) }; __ret } else { aiur_fn_427(__args, record, io_buffer, __cu)? } };
-                let __v_28: G = __r_arr[0];
-                let __ret: [G; OUT_397] = [__v_27, __v_28];
-                record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __v_23: G = G::from_u64(0);
+                let __ret: [G; OUT_309] = [__v_23];
+                record.function_queries[309].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
                 return Err(ExecError::MatchNoCase(__v_22.as_canonical_u64()));
-              },
-            }
-          },
-          _ => {
-            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 __v_24: G = G::from_u64(0);
-            let __v_25: G = { let __values: [G; 4] = [__v_22, __v_23, __v_24, __v_24]; 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_397] = [__v_21, __v_25];
-            record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
+              },
+            }
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64()));
           },
         }
       },
       _ => {
-        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 = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; 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_397] = [__v_15, __v_19];
-        record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_398: usize = 5;
-const IN_398: usize = 5;
-const OUT_398: usize = 2;
-fn aiur_fn_398(
-  inp: [G; IN_398],
+const INPUT_SIZE_310: usize = 2;
+const IN_310: usize = 2;
+const OUT_310: usize = 1;
+fn aiur_fn_310(
+  inp: [G; IN_310],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_398], ExecError> {
+) -> Result<[G; OUT_310], 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_778] = { let __args: [G; IN_778] = [__v_4, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-    let __v_5: G = __r_arr[0];
-    let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } else { aiur_fn_254(__args, record, io_buffer, __cu)? } };
-    let __v_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_7: G = __r_arr[0];
-    match __v_7.as_canonical_u64() {
-      0u64 => {
-        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 = { let __values: [G; 4] = [__v_9, __v_10, __v_11, __v_11]; 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_398] = [__v_8, __v_12];
-        record.function_queries[398].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() {
       1u64 => {
-        match __v_1.as_canonical_u64() {
+        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_5: G = __loaded[0];
+        let __v_6: G = __loaded[1];
+        let __v_7: G = __loaded[2];
+        match __v_5.as_canonical_u64() {
+          1u64 => {
+            let __v_8: G = G::from_u64(1);
+            let __ret: [G; OUT_310] = [__v_8];
+            record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            let __v_8: G = G::from_u64(0);
+            let __ret: [G; OUT_310] = [__v_8];
+            record.function_queries[310].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_5: G = __loaded[0];
+        let __v_6: G = __loaded[1];
+        let __v_7: G = __loaded[2];
+        match __v_5.as_canonical_u64() {
+          1u64 => {
+            let __v_8: G = G::from_u64(0);
+            let __ret: [G; OUT_310] = [__v_8];
+            record.function_queries[310].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_8: G = __loaded[0];
-            let __v_9: G = __loaded[1];
-            let __v_10: G = __loaded[2];
-            let __v_11: G = __loaded[3];
+            let __v_8: G = (__v_3 - __v_6);
             match __v_8.as_canonical_u64() {
-              2u64 => {
-                let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_4, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-                let __v_12: G = __r_arr[0];
-                let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } else { aiur_fn_255(__args, record, io_buffer, __cu)? } };
-                let __v_13: G = __r_arr[0];
-                let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_14: G = __r_arr[0];
-                match __v_14.as_canonical_u64() {
-                  0u64 => {
-                    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 = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; 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_398] = [__v_15, __v_19];
-                    record.function_queries[398].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
-                  1u64 => {
-                    let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { 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_15: G = __r_arr[0];
-                    let __v_16: G = G::from_u64(5);
-                    let __v_17: G = { let __a_val = __v_15.as_canonical_u64(); let __b_val = __v_16.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_17.as_canonical_u64() {
-                      1u64 => {
-                        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 = { let __values: [G; 4] = [__v_19, __v_20, __v_21, __v_21]; 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_398] = [__v_18, __v_22];
-                        record.function_queries[398].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                        return Ok(__ret);
-                      },
-                      0u64 => {
-                        let __v_18: G = G::from_u64(0);
-                        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_3, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-                        let __v_19: G = __r_arr[0];
-                        let __v_20: G = G::from_u64(1);
-                        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_3, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-                        let __v_21: G = __r_arr[0];
-                        let __v_22: G = G::from_u64(2);
-                        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_3, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-                        let __v_23: G = __r_arr[0];
-                        let __v_24: G = G::from_u64(3);
-                        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_3, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-                        let __v_25: G = __r_arr[0];
-                        let __v_26: G = G::from_u64(4);
-                        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_3, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-                        let __v_27: 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_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: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
-                        let __v_28: G = __loaded[0];
-                        let __v_29: G = __loaded[1];
-                        let __v_30: G = __loaded[2];
-                        let __v_31: G = __loaded[3];
-                        match __v_28.as_canonical_u64() {
-                          4u64 => {
-                            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_23.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).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_32: G = __loaded[0];
-                            let __v_33: G = __loaded[1];
-                            let __v_34: G = __loaded[2];
-                            let __v_35: G = __loaded[3];
-                            match __v_32.as_canonical_u64() {
-                              4u64 => {
-                                let __v_36: G = G::from_u64(8);
-                                let __v_37: G = { let __values: [G; 4] = [__v_36, __v_0, __v_1, __v_34]; 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_38: G = G::from_u64(4);
-                                let __v_39: G = G::from_u64(0);
-                                let __v_40: G = { let __values: [G; 4] = [__v_38, __v_33, __v_37, __v_39]; 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 __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_41: G = __loaded[0];
-                                let __v_42: G = __loaded[1];
-                                let __v_43: G = __loaded[2];
-                                let __v_44: G = __loaded[3];
-                                match __v_41.as_canonical_u64() {
-                                  4u64 => {
-                                    let __v_45: G = G::from_u64(8);
-                                    let __v_46: G = { let __values: [G; 4] = [__v_45, __v_0, __v_1, __v_43]; 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_47: G = G::from_u64(4);
-                                    let __v_48: G = G::from_u64(0);
-                                    let __v_49: G = { let __values: [G; 4] = [__v_47, __v_42, __v_46, __v_48]; 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_271] = { let __args: [G; IN_271] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[271].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_271] = unsafe { *(result.output.as_ptr() as *const [G; OUT_271]) }; __ret } else { aiur_fn_271(__args, record, io_buffer, __cu)? } };
-                                    let __v_50: G = __r_arr[0];
-                                    let __v_51: G = G::from_u64(0);
-                                    let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_50, __v_4, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } else { aiur_fn_334(__args, record, io_buffer, __cu)? } };
-                                    let __v_52: G = __r_arr[0];
-                                    let __v_53: G = __r_arr[1];
-                                    match __v_52.as_canonical_u64() {
-                                      1u64 => {
-                                        let __v_54: G = G::from_u64(2);
-                                        let __v_55: G = G::from_u64(1);
-                                        let __v_56: G = G::from_u64(1);
-                                        let __v_57: G = { let __values: [G; 3] = [__v_55, __v_56, __v_56]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                        let __v_58: G = G::from_u64(0);
-                                        let __v_59: G = { let __values: [G; 4] = [__v_54, __v_53, __v_57, __v_58]; 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_60: G = G::from_u64(4);
-                                        let __v_61: G = G::from_u64(0);
-                                        let __v_62: G = { let __values: [G; 4] = [__v_60, __v_29, __v_59, __v_61]; 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_63: G = G::from_u64(2);
-                                        let __v_64: G = G::from_u64(0);
-                                        let __v_65: G = { let __values: [G; 4] = [__v_63, __v_9, __v_10, __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 __v_66: G = G::from_u64(3);
-                                        let __v_67: G = G::from_u64(0);
-                                        let __v_68: G = { let __values: [G; 4] = [__v_66, __v_65, __v_19, __v_67]; 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_69: G = G::from_u64(3);
-                                        let __v_70: G = G::from_u64(0);
-                                        let __v_71: G = { let __values: [G; 4] = [__v_69, __v_68, __v_62, __v_70]; 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_72: G = G::from_u64(3);
-                                        let __v_73: G = G::from_u64(0);
-                                        let __v_74: G = { let __values: [G; 4] = [__v_72, __v_71, __v_40, __v_73]; 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_75: G = G::from_u64(3);
-                                        let __v_76: G = G::from_u64(0);
-                                        let __v_77: G = { let __values: [G; 4] = [__v_75, __v_74, __v_49, __v_76]; 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_78: G = G::from_u64(3);
-                                        let __v_79: G = G::from_u64(0);
-                                        let __v_80: G = { let __values: [G; 4] = [__v_78, __v_77, __v_27, __v_79]; 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_81: G = G::from_u64(5);
-                                        let __r_arr: [G; OUT_796] = { let __args: [G; IN_796] = [__v_3, __v_81]; let __cu = unconstrained; if let Some(result) = record.function_queries[796].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_796] = unsafe { *(result.output.as_ptr() as *const [G; OUT_796]) }; __ret } else { aiur_fn_796(__args, record, io_buffer, __cu)? } };
-                                        let __v_82: G = __r_arr[0];
-                                        let __v_83: G = G::from_u64(1);
-                                        let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_80, __v_82]; let __cu = unconstrained; if let Some(result) = record.function_queries[427].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_427] = unsafe { *(result.output.as_ptr() as *const [G; OUT_427]) }; __ret } else { aiur_fn_427(__args, record, io_buffer, __cu)? } };
-                                        let __v_84: G = __r_arr[0];
-                                        let __ret: [G; OUT_398] = [__v_83, __v_84];
-                                        record.function_queries[398].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                        return Ok(__ret);
-                                      },
-                                      0u64 => {
-                                        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 = { let __values: [G; 4] = [__v_55, __v_56, __v_57, __v_57]; 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_398] = [__v_54, __v_58];
-                                        record.function_queries[398].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                        return Ok(__ret);
-                                      },
-                                      _ => {
-                                        return Err(ExecError::MatchNoCase(__v_52.as_canonical_u64()));
-                                      },
-                                    }
-                                  },
-                                  _ => {
-                                    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 = { let __values: [G; 4] = [__v_46, __v_47, __v_48, __v_48]; 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_398] = [__v_45, __v_49];
-                                    record.function_queries[398].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                    return Ok(__ret);
-                                  },
-                                }
-                              },
-                              _ => {
-                                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 = { let __values: [G; 4] = [__v_37, __v_38, __v_39, __v_39]; 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_398] = [__v_36, __v_40];
-                                record.function_queries[398].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                return Ok(__ret);
-                              },
-                            }
-                          },
-                          _ => {
-                            let __v_32: G = G::from_u64(0);
-                            let __v_33: G = G::from_u64(0);
-                            let __v_34: G = G::from_u64(0);
-                            let __v_35: G = G::from_u64(0);
-                            let __v_36: G = { let __values: [G; 4] = [__v_33, __v_34, __v_35, __v_35]; 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_398] = [__v_32, __v_36];
-                            record.function_queries[398].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                            return Ok(__ret);
-                          },
-                        }
-                      },
-                      _ => {
-                        return Err(ExecError::MatchNoCase(__v_17.as_canonical_u64()));
-                      },
-                    }
-                  },
-                  _ => {
-                    return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64()));
-                  },
-                }
+              0u64 => {
+                let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } else { aiur_fn_310(__args, record, io_buffer, __cu)? } };
+                let __v_9: G = __r_arr[0];
+                let __ret: [G; OUT_310] = [__v_9];
+                record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
               },
               _ => {
-                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 = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; 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_398] = [__v_12, __v_16];
-                record.function_queries[398].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __v_9: G = G::from_u64(0);
+                let __ret: [G; OUT_310] = [__v_9];
+                record.function_queries[310].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(0);
-            let __v_10: G = G::from_u64(0);
-            let __v_11: G = G::from_u64(0);
-            let __v_12: G = { let __values: [G; 4] = [__v_9, __v_10, __v_11, __v_11]; 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_398] = [__v_8, __v_12];
-            record.function_queries[398].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
+            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
           },
         }
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64()));
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_399: usize = 2;
-const IN_399: usize = 2;
-const OUT_399: usize = 5;
-fn aiur_fn_399(
-  inp: [G; IN_399],
+const INPUT_SIZE_311: usize = 4;
+const IN_311: usize = 4;
+const OUT_311: usize = 1;
+fn aiur_fn_311(
+  inp: [G; IN_311],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_399], ExecError> {
+) -> Result<[G; OUT_311], 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() {
-      4u64 => {
-        let __v_6: G = G::from_u64(1);
-        let __v_7: G = (__v_1 + __v_6);
-        let __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[399].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_399] = unsafe { *(result.output.as_ptr() as *const [G; OUT_399]) }; __ret } else { aiur_fn_399(__args, record, io_buffer, __cu)? } };
-        let __v_8: G = __r_arr[0];
-        let __v_9: G = __r_arr[1];
-        let __v_10: G = __r_arr[2];
-        let __v_11: G = __r_arr[3];
-        let __v_12: G = __r_arr[4];
-        let __ret: [G; OUT_399] = [__v_8, __v_9, __v_10, __v_11, __v_12];
-        record.function_queries[399].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      8u64 => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; 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: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].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];
-        match __v_6.as_canonical_u64() {
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        match __v_2.as_canonical_u64() {
           0u64 => {
-            let __v_10: G = { let __a_val = __v_7.as_canonical_u64(); let __b_val = __v_1.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_10.as_canonical_u64() {
-              1u64 => {
-                let __v_11: G = G::from_u64(1);
-                let __v_12: G = G::from_u64(1);
-                let __v_13: G = (__v_1 - __v_12);
-                let __v_14: G = (__v_13 - __v_7);
-                let __ret: [G; OUT_399] = [__v_11, __v_1, __v_3, __v_4, __v_14];
-                record.function_queries[399].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              _ => {
-                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 __ret: [G; OUT_399] = [__v_11, __v_12, __v_13, __v_14, __v_15];
-                record.function_queries[399].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-            }
+            let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } };
+            let __v_4: G = __r_arr[0];
+            let __ret: [G; OUT_311] = [__v_4];
+            record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
           },
           _ => {
-            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 __ret: [G; OUT_399] = [__v_10, __v_11, __v_12, __v_13, __v_14];
-            record.function_queries[399].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __v_4: G = G::from_u64(0);
+            let __ret: [G; OUT_311] = [__v_4];
+            record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+        }
+      },
+      1u64 => {
+        match __v_2.as_canonical_u64() {
+          1u64 => {
+            let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } else { aiur_fn_310(__args, record, io_buffer, __cu)? } };
+            let __v_4: G = __r_arr[0];
+            let __ret: [G; OUT_311] = [__v_4];
+            record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            let __v_4: G = G::from_u64(0);
+            let __ret: [G; OUT_311] = [__v_4];
+            record.function_queries[311].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(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 __ret: [G; OUT_399] = [__v_6, __v_7, __v_8, __v_9, __v_10];
-        record.function_queries[399].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
+        return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_400: usize = 1;
-const IN_400: usize = 1;
-const OUT_400: usize = 1;
-fn aiur_fn_400(
-  inp: [G; IN_400],
+const INPUT_SIZE_312: usize = 1;
+const IN_312: usize = 1;
+const OUT_312: usize = 1;
+fn aiur_fn_312(
+  inp: [G; IN_312],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_400], ExecError> {
+) -> Result<[G; OUT_312], 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 };
@@ -37202,77 +28938,77 @@ fn aiur_fn_400(
       0u64 => {
         let __v_5: G = G::from_u64(1);
         let __v_6: G = (__v_2 + __v_5);
-        let __ret: [G; OUT_400] = [__v_6];
-        record.function_queries[400].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_312] = [__v_6];
+        record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
         let __v_5: G = G::from_u64(0);
-        let __ret: [G; OUT_400] = [__v_5];
-        record.function_queries[400].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_312] = [__v_5];
+        record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
         let __v_5: G = G::from_u64(0);
-        let __ret: [G; OUT_400] = [__v_5];
-        record.function_queries[400].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_312] = [__v_5];
+        record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       7u64 => {
         let __v_5: G = G::from_u64(0);
-        let __ret: [G; OUT_400] = [__v_5];
-        record.function_queries[400].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_312] = [__v_5];
+        record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_402] = { let __args: [G; IN_402] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[402].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_402] = unsafe { *(result.output.as_ptr() as *const [G; OUT_402]) }; __ret } else { aiur_fn_402(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } else { aiur_fn_314(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_400] = [__v_7];
-        record.function_queries[400].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_312] = [__v_7];
+        record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       4u64 => {
-        let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_403] = { let __args: [G; IN_403] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[403].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_403] = unsafe { *(result.output.as_ptr() as *const [G; OUT_403]) }; __ret } else { aiur_fn_403(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = unsafe { *(result.output.as_ptr() as *const [G; OUT_315]) }; __ret } else { aiur_fn_315(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_402] = { let __args: [G; IN_402] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[402].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_402] = unsafe { *(result.output.as_ptr() as *const [G; OUT_402]) }; __ret } else { aiur_fn_402(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } else { aiur_fn_314(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
-        let __ret: [G; OUT_400] = [__v_8];
-        record.function_queries[400].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_312] = [__v_8];
+        record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       5u64 => {
-        let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_403] = { let __args: [G; IN_403] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[403].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_403] = unsafe { *(result.output.as_ptr() as *const [G; OUT_403]) }; __ret } else { aiur_fn_403(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = unsafe { *(result.output.as_ptr() as *const [G; OUT_315]) }; __ret } else { aiur_fn_315(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_402] = { let __args: [G; IN_402] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[402].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_402] = unsafe { *(result.output.as_ptr() as *const [G; OUT_402]) }; __ret } else { aiur_fn_402(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } else { aiur_fn_314(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
-        let __ret: [G; OUT_400] = [__v_8];
-        record.function_queries[400].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_312] = [__v_8];
+        record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       6u64 => {
-        let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[313].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_313] = unsafe { *(result.output.as_ptr() as *const [G; OUT_313]) }; __ret } else { aiur_fn_313(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
-        let __ret: [G; OUT_400] = [__v_5];
-        record.function_queries[400].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_312] = [__v_5];
+        record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       8u64 => {
-        let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
-        let __ret: [G; OUT_400] = [__v_5];
-        record.function_queries[400].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_312] = [__v_5];
+        record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -37282,59 +29018,59 @@ fn aiur_fn_400(
   })
 }
 
-const INPUT_SIZE_401: usize = 3;
-const IN_401: usize = 3;
-const OUT_401: usize = 1;
-fn aiur_fn_401(
-  inp: [G; IN_401],
+const INPUT_SIZE_313: usize = 3;
+const IN_313: usize = 3;
+const OUT_313: usize = 1;
+fn aiur_fn_313(
+  inp: [G; IN_313],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_401], ExecError> {
+) -> Result<[G; OUT_313], 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_400] = { let __args: [G; IN_400] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
-    let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
-    let __r_arr: [G; OUT_402] = { let __args: [G; IN_402] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[402].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_402] = unsafe { *(result.output.as_ptr() as *const [G; OUT_402]) }; __ret } else { aiur_fn_402(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } else { aiur_fn_314(__args, record, io_buffer, __cu)? } };
     let __v_5: G = __r_arr[0];
-    let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } };
     let __v_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_403] = { let __args: [G; IN_403] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[403].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_403] = unsafe { *(result.output.as_ptr() as *const [G; OUT_403]) }; __ret } else { aiur_fn_403(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = unsafe { *(result.output.as_ptr() as *const [G; OUT_315]) }; __ret } else { aiur_fn_315(__args, record, io_buffer, __cu)? } };
     let __v_7: G = __r_arr[0];
-    let __r_arr: [G; OUT_402] = { let __args: [G; IN_402] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[402].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_402] = unsafe { *(result.output.as_ptr() as *const [G; OUT_402]) }; __ret } else { aiur_fn_402(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } else { aiur_fn_314(__args, record, io_buffer, __cu)? } };
     let __v_8: G = __r_arr[0];
-    let __ret: [G; OUT_401] = [__v_8];
-    record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_313] = [__v_8];
+    record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_402: usize = 2;
-const IN_402: usize = 2;
-const OUT_402: usize = 1;
-fn aiur_fn_402(
-  inp: [G; IN_402],
+const INPUT_SIZE_314: usize = 2;
+const IN_314: usize = 2;
+const OUT_314: usize = 1;
+fn aiur_fn_314(
+  inp: [G; IN_314],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_402], ExecError> {
+) -> Result<[G; OUT_314], 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 = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_1.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_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_402] = [__v_1];
-        record.function_queries[402].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_314] = [__v_1];
+        record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __ret: [G; OUT_402] = [__v_0];
-        record.function_queries[402].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_314] = [__v_0];
+        record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -37344,57 +29080,57 @@ fn aiur_fn_402(
   })
 }
 
-const INPUT_SIZE_403: usize = 1;
-const IN_403: usize = 1;
-const OUT_403: usize = 1;
-fn aiur_fn_403(
-  inp: [G; IN_403],
+const INPUT_SIZE_315: usize = 1;
+const IN_315: usize = 1;
+const OUT_315: usize = 1;
+fn aiur_fn_315(
+  inp: [G; IN_315],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_403], ExecError> {
+) -> Result<[G; OUT_315], 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(0);
-        let __ret: [G; OUT_403] = [__v_1];
-        record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_315] = [__v_1];
+        record.function_queries[315].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 __ret: [G; OUT_403] = [__v_2];
-        record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_315] = [__v_2];
+        record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_404: usize = 2;
-const IN_404: usize = 2;
-const OUT_404: usize = 1;
-fn aiur_fn_404(
-  inp: [G; IN_404],
+const INPUT_SIZE_316: usize = 2;
+const IN_316: usize = 2;
+const OUT_316: usize = 1;
+fn aiur_fn_316(
+  inp: [G; IN_316],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_404], ExecError> {
+) -> Result<[G; OUT_316], 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 = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_1.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_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_404] = [__v_0];
-        record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_316] = [__v_0];
+        record.function_queries[316].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __ret: [G; OUT_404] = [__v_1];
-        record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_316] = [__v_1];
+        record.function_queries[316].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -37404,15 +29140,15 @@ fn aiur_fn_404(
   })
 }
 
-const INPUT_SIZE_405: usize = 3;
-const IN_405: usize = 3;
-const OUT_405: usize = 1;
-fn aiur_fn_405(
-  inp: [G; IN_405],
+const INPUT_SIZE_317: usize = 3;
+const IN_317: usize = 3;
+const OUT_317: usize = 1;
+fn aiur_fn_317(
+  inp: [G; IN_317],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_405], ExecError> {
+) -> Result<[G; OUT_317], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -37428,14 +29164,14 @@ fn aiur_fn_405(
         match __v_7.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_405] = [__v_8];
-            record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_317] = [__v_8];
+            record.function_queries[317].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
             let __v_8: 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 };
-            let __ret: [G; OUT_405] = [__v_8];
-            record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_317] = [__v_8];
+            record.function_queries[317].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -37445,37 +29181,37 @@ fn aiur_fn_405(
       },
       1u64 => {
         let __v_7: G = G::from_u64(0);
-        let __ret: [G; OUT_405] = [__v_7];
-        record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_317] = [__v_7];
+        record.function_queries[317].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
         let __v_7: G = G::from_u64(0);
-        let __ret: [G; OUT_405] = [__v_7];
-        record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_317] = [__v_7];
+        record.function_queries[317].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       7u64 => {
         let __v_7: G = G::from_u64(0);
-        let __ret: [G; OUT_405] = [__v_7];
-        record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_317] = [__v_7];
+        record.function_queries[317].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_405] = { let __args: [G; IN_405] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[405].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_405] = unsafe { *(result.output.as_ptr() as *const [G; OUT_405]) }; __ret } else { aiur_fn_405(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = unsafe { *(result.output.as_ptr() as *const [G; OUT_317]) }; __ret } else { aiur_fn_317(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
         match __v_7.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(1);
-            let __ret: [G; OUT_405] = [__v_8];
-            record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_317] = [__v_8];
+            record.function_queries[317].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_405] = { let __args: [G; IN_405] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[405].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_405] = unsafe { *(result.output.as_ptr() as *const [G; OUT_405]) }; __ret } else { aiur_fn_405(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = unsafe { *(result.output.as_ptr() as *const [G; OUT_317]) }; __ret } else { aiur_fn_317(__args, record, io_buffer, __cu)? } };
             let __v_8: G = __r_arr[0];
-            let __ret: [G; OUT_405] = [__v_8];
-            record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_317] = [__v_8];
+            record.function_queries[317].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -37484,31 +29220,31 @@ fn aiur_fn_405(
         }
       },
       4u64 => {
-        let __r_arr: [G; OUT_406] = { let __args: [G; IN_406] = [__v_4, __v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[406].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_406] = unsafe { *(result.output.as_ptr() as *const [G; OUT_406]) }; __ret } else { aiur_fn_406(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_4, __v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[318].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_318] = unsafe { *(result.output.as_ptr() as *const [G; OUT_318]) }; __ret } else { aiur_fn_318(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_405] = [__v_7];
-        record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_317] = [__v_7];
+        record.function_queries[317].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       5u64 => {
-        let __r_arr: [G; OUT_406] = { let __args: [G; IN_406] = [__v_4, __v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[406].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_406] = unsafe { *(result.output.as_ptr() as *const [G; OUT_406]) }; __ret } else { aiur_fn_406(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_4, __v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[318].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_318] = unsafe { *(result.output.as_ptr() as *const [G; OUT_318]) }; __ret } else { aiur_fn_318(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_405] = [__v_7];
-        record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_317] = [__v_7];
+        record.function_queries[317].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       6u64 => {
-        let __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[407].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_407] = unsafe { *(result.output.as_ptr() as *const [G; OUT_407]) }; __ret } else { aiur_fn_407(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = unsafe { *(result.output.as_ptr() as *const [G; OUT_319]) }; __ret } else { aiur_fn_319(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_405] = [__v_7];
-        record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_317] = [__v_7];
+        record.function_queries[317].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       8u64 => {
-        let __r_arr: [G; OUT_405] = { let __args: [G; IN_405] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[405].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_405] = unsafe { *(result.output.as_ptr() as *const [G; OUT_405]) }; __ret } else { aiur_fn_405(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = unsafe { *(result.output.as_ptr() as *const [G; OUT_317]) }; __ret } else { aiur_fn_317(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_405] = [__v_7];
-        record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_317] = [__v_7];
+        record.function_queries[317].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -37518,27 +29254,27 @@ fn aiur_fn_405(
   })
 }
 
-const INPUT_SIZE_406: usize = 4;
-const IN_406: usize = 4;
-const OUT_406: usize = 1;
-fn aiur_fn_406(
-  inp: [G; IN_406],
+const INPUT_SIZE_318: usize = 4;
+const IN_318: usize = 4;
+const OUT_318: usize = 1;
+fn aiur_fn_318(
+  inp: [G; IN_318],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_406], ExecError> {
+) -> Result<[G; OUT_318], 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_405] = { let __args: [G; IN_405] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[405].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_405] = unsafe { *(result.output.as_ptr() as *const [G; OUT_405]) }; __ret } else { aiur_fn_405(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = unsafe { *(result.output.as_ptr() as *const [G; OUT_317]) }; __ret } else { aiur_fn_317(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
     match __v_4.as_canonical_u64() {
       1u64 => {
         let __v_5: G = G::from_u64(1);
-        let __ret: [G; OUT_406] = [__v_5];
-        record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_318] = [__v_5];
+        record.function_queries[318].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -37546,10 +29282,10 @@ fn aiur_fn_406(
         let __v_6: G = (__v_2 + __v_5);
         let __v_7: G = G::from_u64(1);
         let __v_8: G = (__v_3 + __v_7);
-        let __r_arr: [G; OUT_405] = { let __args: [G; IN_405] = [__v_1, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[405].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_405] = unsafe { *(result.output.as_ptr() as *const [G; OUT_405]) }; __ret } else { aiur_fn_405(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_1, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = unsafe { *(result.output.as_ptr() as *const [G; OUT_317]) }; __ret } else { aiur_fn_317(__args, record, io_buffer, __cu)? } };
         let __v_9: G = __r_arr[0];
-        let __ret: [G; OUT_406] = [__v_9];
-        record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_318] = [__v_9];
+        record.function_queries[318].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -37559,38 +29295,38 @@ fn aiur_fn_406(
   })
 }
 
-const INPUT_SIZE_407: usize = 5;
-const IN_407: usize = 5;
-const OUT_407: usize = 1;
-fn aiur_fn_407(
-  inp: [G; IN_407],
+const INPUT_SIZE_319: usize = 5;
+const IN_319: usize = 5;
+const OUT_319: usize = 1;
+fn aiur_fn_319(
+  inp: [G; IN_319],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_407], ExecError> {
+) -> Result<[G; OUT_319], 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_405] = { let __args: [G; IN_405] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[405].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_405] = unsafe { *(result.output.as_ptr() as *const [G; OUT_405]) }; __ret } else { aiur_fn_405(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = unsafe { *(result.output.as_ptr() as *const [G; OUT_317]) }; __ret } else { aiur_fn_317(__args, record, io_buffer, __cu)? } };
     let __v_5: G = __r_arr[0];
     match __v_5.as_canonical_u64() {
       1u64 => {
         let __v_6: G = G::from_u64(1);
-        let __ret: [G; OUT_407] = [__v_6];
-        record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_319] = [__v_6];
+        record.function_queries[319].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_405] = { let __args: [G; IN_405] = [__v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[405].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_405] = unsafe { *(result.output.as_ptr() as *const [G; OUT_405]) }; __ret } else { aiur_fn_405(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = unsafe { *(result.output.as_ptr() as *const [G; OUT_317]) }; __ret } else { aiur_fn_317(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
         match __v_6.as_canonical_u64() {
           1u64 => {
             let __v_7: G = G::from_u64(1);
-            let __ret: [G; OUT_407] = [__v_7];
-            record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_319] = [__v_7];
+            record.function_queries[319].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
@@ -37598,10 +29334,10 @@ fn aiur_fn_407(
             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_405] = { let __args: [G; IN_405] = [__v_2, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[405].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_405] = unsafe { *(result.output.as_ptr() as *const [G; OUT_405]) }; __ret } else { aiur_fn_405(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_2, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = unsafe { *(result.output.as_ptr() as *const [G; OUT_317]) }; __ret } else { aiur_fn_317(__args, record, io_buffer, __cu)? } };
             let __v_11: G = __r_arr[0];
-            let __ret: [G; OUT_407] = [__v_11];
-            record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_319] = [__v_11];
+            record.function_queries[319].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -37616,60 +29352,60 @@ fn aiur_fn_407(
   })
 }
 
-const INPUT_SIZE_408: usize = 2;
-const IN_408: usize = 2;
-const OUT_408: usize = 1;
-fn aiur_fn_408(
-  inp: [G; IN_408],
+const INPUT_SIZE_320: usize = 2;
+const IN_320: usize = 2;
+const OUT_320: usize = 1;
+fn aiur_fn_320(
+  inp: [G; IN_320],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_408], ExecError> {
+) -> Result<[G; OUT_320], 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_187] = { let __args: [G; IN_187] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } else { aiur_fn_711(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
-    let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[404].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_404] = unsafe { *(result.output.as_ptr() as *const [G; OUT_404]) }; __ret } else { aiur_fn_404(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[316].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_316] = unsafe { *(result.output.as_ptr() as *const [G; OUT_316]) }; __ret } else { aiur_fn_316(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
-    let __r_arr: [G; OUT_409] = { let __args: [G; IN_409] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[409].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_409] = unsafe { *(result.output.as_ptr() as *const [G; OUT_409]) }; __ret } else { aiur_fn_409(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } else { aiur_fn_321(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
-    let __ret: [G; OUT_408] = [__v_4];
-    record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_320] = [__v_4];
+    record.function_queries[320].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_409: usize = 2;
-const IN_409: usize = 2;
-const OUT_409: usize = 1;
-fn aiur_fn_409(
-  inp: [G; IN_409],
+const INPUT_SIZE_321: usize = 2;
+const IN_321: usize = 2;
+const OUT_321: usize = 1;
+fn aiur_fn_321(
+  inp: [G; IN_321],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_409], ExecError> {
+) -> Result<[G; OUT_321], 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_410] = { let __args: [G; IN_410] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[410].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_410] = unsafe { *(result.output.as_ptr() as *const [G; OUT_410]) }; __ret } else { aiur_fn_410(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_322] = { let __args: [G; IN_322] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[322].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_322] = unsafe { *(result.output.as_ptr() as *const [G; OUT_322]) }; __ret } else { aiur_fn_322(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
     let __v_3: G = { let __a_val = __v_2.as_canonical_u64(); let __b_val = __v_1.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_3.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_409] = [__v_2];
-        record.function_queries[409].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_321] = [__v_2];
+        record.function_queries[321].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_796] = { let __args: [G; IN_796] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[796].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_796] = unsafe { *(result.output.as_ptr() as *const [G; OUT_796]) }; __ret } else { aiur_fn_796(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } };
         let __v_4: G = __r_arr[0];
         let __v_5: G = (__v_1 - __v_2);
-        let __r_arr: [G; OUT_409] = { let __args: [G; IN_409] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[409].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_409] = unsafe { *(result.output.as_ptr() as *const [G; OUT_409]) }; __ret } else { aiur_fn_409(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } else { aiur_fn_321(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
         let __v_7: G = (__v_2 + __v_6);
-        let __ret: [G; OUT_409] = [__v_7];
-        record.function_queries[409].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_321] = [__v_7];
+        record.function_queries[321].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -37679,15 +29415,15 @@ fn aiur_fn_409(
   })
 }
 
-const INPUT_SIZE_410: usize = 1;
-const IN_410: usize = 1;
-const OUT_410: usize = 1;
-fn aiur_fn_410(
-  inp: [G; IN_410],
+const INPUT_SIZE_322: usize = 1;
+const IN_322: usize = 1;
+const OUT_322: usize = 1;
+fn aiur_fn_322(
+  inp: [G; IN_322],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_410], ExecError> {
+) -> Result<[G; OUT_322], 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 };
@@ -37697,13 +29433,13 @@ fn aiur_fn_410(
     match __v_1.as_canonical_u64() {
       0u64 => {
         let __v_4: G = G::from_u64(1);
-        let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_411] = { let __args: [G; IN_411] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[411].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_411] = unsafe { *(result.output.as_ptr() as *const [G; OUT_411]) }; __ret } else { aiur_fn_411(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } else { aiur_fn_323(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
         let __v_7: G = (__v_4 + __v_6);
-        let __ret: [G; OUT_410] = [__v_7];
-        record.function_queries[410].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_322] = [__v_7];
+        record.function_queries[322].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -37713,44 +29449,44 @@ fn aiur_fn_410(
   })
 }
 
-const INPUT_SIZE_411: usize = 2;
-const IN_411: usize = 2;
-const OUT_411: usize = 1;
-fn aiur_fn_411(
-  inp: [G; IN_411],
+const INPUT_SIZE_323: usize = 2;
+const IN_323: usize = 2;
+const OUT_323: usize = 1;
+fn aiur_fn_323(
+  inp: [G; IN_323],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_411], ExecError> {
+) -> Result<[G; OUT_323], 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(0);
-        let __ret: [G; OUT_411] = [__v_2];
-        record.function_queries[411].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_323] = [__v_2];
+        record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[410].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_410] = unsafe { *(result.output.as_ptr() as *const [G; OUT_410]) }; __ret } else { aiur_fn_410(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_322] = { let __args: [G; IN_322] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[322].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_322] = unsafe { *(result.output.as_ptr() as *const [G; OUT_322]) }; __ret } else { aiur_fn_322(__args, record, io_buffer, __cu)? } };
         let __v_2: G = __r_arr[0];
         let __v_3: G = { let __a_val = __v_2.as_canonical_u64(); let __b_val = __v_1.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_3.as_canonical_u64() {
           0u64 => {
-            let __ret: [G; OUT_411] = [__v_2];
-            record.function_queries[411].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_323] = [__v_2];
+            record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
-            let __r_arr: [G; OUT_796] = { let __args: [G; IN_796] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[796].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_796] = unsafe { *(result.output.as_ptr() as *const [G; OUT_796]) }; __ret } else { aiur_fn_796(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } };
             let __v_4: G = __r_arr[0];
             let __v_5: G = (__v_1 - __v_2);
-            let __r_arr: [G; OUT_411] = { let __args: [G; IN_411] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[411].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_411] = unsafe { *(result.output.as_ptr() as *const [G; OUT_411]) }; __ret } else { aiur_fn_411(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } else { aiur_fn_323(__args, record, io_buffer, __cu)? } };
             let __v_6: G = __r_arr[0];
             let __v_7: G = (__v_2 + __v_6);
-            let __ret: [G; OUT_411] = [__v_7];
-            record.function_queries[411].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_323] = [__v_7];
+            record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -37762,15 +29498,15 @@ fn aiur_fn_411(
   })
 }
 
-const INPUT_SIZE_412: usize = 2;
-const IN_412: usize = 2;
-const OUT_412: usize = 1;
-fn aiur_fn_412(
-  inp: [G; IN_412],
+const INPUT_SIZE_324: usize = 2;
+const IN_324: usize = 2;
+const OUT_324: usize = 1;
+fn aiur_fn_324(
+  inp: [G; IN_324],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_412], ExecError> {
+) -> Result<[G; OUT_324], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -37779,27 +29515,27 @@ fn aiur_fn_412(
         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_412] = [__v_4];
-        record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_324] = [__v_4];
+        record.function_queries[324].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } else { aiur_fn_711(__args, record, io_buffer, __cu)? } };
         let __v_2: G = __r_arr[0];
         let __v_3: G = { let __a_val = __v_1.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_3.as_canonical_u64() {
           0u64 => {
-            let __ret: [G; OUT_412] = [__v_0];
-            record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_324] = [__v_0];
+            record.function_queries[324].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
-            let __r_arr: [G; OUT_408] = { let __args: [G; IN_408] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[408].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_408] = unsafe { *(result.output.as_ptr() as *const [G; OUT_408]) }; __ret } else { aiur_fn_408(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } else { aiur_fn_320(__args, record, io_buffer, __cu)? } };
             let __v_4: G = __r_arr[0];
-            let __r_arr: [G; OUT_792] = { let __args: [G; IN_792] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[792].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_792] = unsafe { *(result.output.as_ptr() as *const [G; OUT_792]) }; __ret } else { aiur_fn_792(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } else { aiur_fn_721(__args, record, io_buffer, __cu)? } };
             let __v_5: G = __r_arr[0];
-            let __ret: [G; OUT_412] = [__v_5];
-            record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_324] = [__v_5];
+            record.function_queries[324].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -37811,40 +29547,40 @@ fn aiur_fn_412(
   })
 }
 
-const INPUT_SIZE_413: usize = 3;
-const IN_413: usize = 3;
-const OUT_413: usize = 1;
-fn aiur_fn_413(
-  inp: [G; IN_413],
+const INPUT_SIZE_325: usize = 3;
+const IN_325: usize = 3;
+const OUT_325: usize = 1;
+fn aiur_fn_325(
+  inp: [G; IN_325],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_413], ExecError> {
+) -> Result<[G; OUT_325], 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_1.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_413] = [__v_0];
-        record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_325] = [__v_0];
+        record.function_queries[325].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } };
         let __v_3: G = __r_arr[0];
         let __v_4: G = { let __a_val = __v_2.as_canonical_u64(); let __b_val = __v_3.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_4.as_canonical_u64() {
           0u64 => {
-            let __ret: [G; OUT_413] = [__v_0];
-            record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_325] = [__v_0];
+            record.function_queries[325].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
-            let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } else { aiur_fn_414(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[326].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_326] = unsafe { *(result.output.as_ptr() as *const [G; OUT_326]) }; __ret } else { aiur_fn_326(__args, record, io_buffer, __cu)? } };
             let __v_5: G = __r_arr[0];
-            let __ret: [G; OUT_413] = [__v_5];
-            record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_325] = [__v_5];
+            record.function_queries[325].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -37856,15 +29592,15 @@ fn aiur_fn_413(
   })
 }
 
-const INPUT_SIZE_414: usize = 3;
-const IN_414: usize = 3;
-const OUT_414: usize = 1;
-fn aiur_fn_414(
-  inp: [G; IN_414],
+const INPUT_SIZE_326: usize = 3;
+const IN_326: usize = 3;
+const OUT_326: usize = 1;
+fn aiur_fn_326(
+  inp: [G; IN_326],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_414], ExecError> {
+) -> Result<[G; OUT_326], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -37876,90 +29612,90 @@ fn aiur_fn_414(
     let __v_6: G = __loaded[3];
     match __v_3.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[327].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_327] = unsafe { *(result.output.as_ptr() as *const [G; OUT_327]) }; __ret } else { aiur_fn_327(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_414] = [__v_7];
-        record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_326] = [__v_7];
+        record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
         let __v_7: G = G::from_u64(1);
         let __v_8: G = G::from_u64(0);
         let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __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_414] = [__v_9];
-        record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_326] = [__v_9];
+        record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
         let __v_7: G = G::from_u64(2);
         let __v_8: G = G::from_u64(0);
         let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __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_414] = [__v_9];
-        record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_326] = [__v_9];
+        record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
         let __v_7: G = G::from_u64(3);
-        let __r_arr: [G; OUT_413] = { let __args: [G; IN_413] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[413].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_413] = unsafe { *(result.output.as_ptr() as *const [G; OUT_413]) }; __ret } else { aiur_fn_413(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[325].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_325] = unsafe { *(result.output.as_ptr() as *const [G; OUT_325]) }; __ret } else { aiur_fn_325(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_413] = { let __args: [G; IN_413] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[413].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_413] = unsafe { *(result.output.as_ptr() as *const [G; OUT_413]) }; __ret } else { aiur_fn_413(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[325].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_325] = unsafe { *(result.output.as_ptr() as *const [G; OUT_325]) }; __ret } else { aiur_fn_325(__args, record, io_buffer, __cu)? } };
         let __v_9: G = __r_arr[0];
         let __v_10: G = G::from_u64(0);
         let __v_11: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __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_414] = [__v_11];
-        record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_326] = [__v_11];
+        record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       4u64 => {
         let __v_7: G = G::from_u64(4);
-        let __r_arr: [G; OUT_413] = { let __args: [G; IN_413] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[413].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_413] = unsafe { *(result.output.as_ptr() as *const [G; OUT_413]) }; __ret } else { aiur_fn_413(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[325].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_325] = unsafe { *(result.output.as_ptr() as *const [G; OUT_325]) }; __ret } else { aiur_fn_325(__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_2 + __v_9);
-        let __r_arr: [G; OUT_413] = { let __args: [G; IN_413] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[413].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_413] = unsafe { *(result.output.as_ptr() as *const [G; OUT_413]) }; __ret } else { aiur_fn_413(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[325].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_325] = unsafe { *(result.output.as_ptr() as *const [G; OUT_325]) }; __ret } else { aiur_fn_325(__args, record, io_buffer, __cu)? } };
         let __v_11: G = __r_arr[0];
         let __v_12: G = G::from_u64(0);
         let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __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_414] = [__v_13];
-        record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_326] = [__v_13];
+        record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       5u64 => {
         let __v_7: G = G::from_u64(5);
-        let __r_arr: [G; OUT_413] = { let __args: [G; IN_413] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[413].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_413] = unsafe { *(result.output.as_ptr() as *const [G; OUT_413]) }; __ret } else { aiur_fn_413(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[325].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_325] = unsafe { *(result.output.as_ptr() as *const [G; OUT_325]) }; __ret } else { aiur_fn_325(__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_2 + __v_9);
-        let __r_arr: [G; OUT_413] = { let __args: [G; IN_413] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[413].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_413] = unsafe { *(result.output.as_ptr() as *const [G; OUT_413]) }; __ret } else { aiur_fn_413(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[325].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_325] = unsafe { *(result.output.as_ptr() as *const [G; OUT_325]) }; __ret } else { aiur_fn_325(__args, record, io_buffer, __cu)? } };
         let __v_11: G = __r_arr[0];
         let __v_12: G = G::from_u64(0);
         let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __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_414] = [__v_13];
-        record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_326] = [__v_13];
+        record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       6u64 => {
-        let __r_arr: [G; OUT_416] = { let __args: [G; IN_416] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[416].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_416] = unsafe { *(result.output.as_ptr() as *const [G; OUT_416]) }; __ret } else { aiur_fn_416(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } else { aiur_fn_328(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_414] = [__v_7];
-        record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_326] = [__v_7];
+        record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       7u64 => {
         let __v_7: G = G::from_u64(7);
         let __v_8: G = G::from_u64(0);
         let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __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_414] = [__v_9];
-        record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_326] = [__v_9];
+        record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       8u64 => {
         let __v_7: G = G::from_u64(8);
-        let __r_arr: [G; OUT_413] = { let __args: [G; IN_413] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[413].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_413] = unsafe { *(result.output.as_ptr() as *const [G; OUT_413]) }; __ret } else { aiur_fn_413(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[325].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_325] = unsafe { *(result.output.as_ptr() as *const [G; OUT_325]) }; __ret } else { aiur_fn_325(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
         let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __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_414] = [__v_9];
-        record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_326] = [__v_9];
+        record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -37969,15 +29705,15 @@ fn aiur_fn_414(
   })
 }
 
-const INPUT_SIZE_415: usize = 3;
-const IN_415: usize = 3;
-const OUT_415: usize = 1;
-fn aiur_fn_415(
-  inp: [G; IN_415],
+const INPUT_SIZE_327: usize = 3;
+const IN_327: usize = 3;
+const OUT_327: usize = 1;
+fn aiur_fn_327(
+  inp: [G; IN_327],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_415], ExecError> {
+) -> Result<[G; OUT_327], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -37988,8 +29724,8 @@ fn aiur_fn_415(
         let __v_4: G = G::from_u64(0);
         let __v_5: G = G::from_u64(0);
         let __v_6: G = { let __values: [G; 4] = [__v_4, __v_0, __v_5, __v_5]; 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_415] = [__v_6];
-        record.function_queries[415].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_327] = [__v_6];
+        record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -37997,8 +29733,8 @@ fn aiur_fn_415(
         let __v_5: G = (__v_0 + __v_1);
         let __v_6: G = G::from_u64(0);
         let __v_7: G = { let __values: [G; 4] = [__v_4, __v_5, __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_415] = [__v_7];
-        record.function_queries[415].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_327] = [__v_7];
+        record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -38008,15 +29744,15 @@ fn aiur_fn_415(
   })
 }
 
-const INPUT_SIZE_416: usize = 5;
-const IN_416: usize = 5;
-const OUT_416: usize = 1;
-fn aiur_fn_416(
-  inp: [G; IN_416],
+const INPUT_SIZE_328: usize = 5;
+const IN_328: usize = 5;
+const OUT_328: usize = 1;
+fn aiur_fn_328(
+  inp: [G; IN_328],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_416], ExecError> {
+) -> Result<[G; OUT_328], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -38024,55 +29760,55 @@ fn aiur_fn_416(
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
     let __v_5: G = G::from_u64(6);
-    let __r_arr: [G; OUT_413] = { let __args: [G; IN_413] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[413].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_413] = unsafe { *(result.output.as_ptr() as *const [G; OUT_413]) }; __ret } else { aiur_fn_413(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[325].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_325] = unsafe { *(result.output.as_ptr() as *const [G; OUT_325]) }; __ret } else { aiur_fn_325(__args, record, io_buffer, __cu)? } };
     let __v_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_413] = { let __args: [G; IN_413] = [__v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[413].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_413] = unsafe { *(result.output.as_ptr() as *const [G; OUT_413]) }; __ret } else { aiur_fn_413(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[325].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_325] = unsafe { *(result.output.as_ptr() as *const [G; OUT_325]) }; __ret } else { aiur_fn_325(__args, record, io_buffer, __cu)? } };
     let __v_7: G = __r_arr[0];
     let __v_8: G = G::from_u64(1);
     let __v_9: G = (__v_4 + __v_8);
-    let __r_arr: [G; OUT_413] = { let __args: [G; IN_413] = [__v_2, __v_3, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[413].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_413] = unsafe { *(result.output.as_ptr() as *const [G; OUT_413]) }; __ret } else { aiur_fn_413(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_2, __v_3, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[325].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_325] = unsafe { *(result.output.as_ptr() as *const [G; OUT_325]) }; __ret } else { aiur_fn_325(__args, record, io_buffer, __cu)? } };
     let __v_10: G = __r_arr[0];
     let __v_11: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __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_416] = [__v_11];
-    record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_328] = [__v_11];
+    record.function_queries[328].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_417: usize = 3;
-const IN_417: usize = 3;
-const OUT_417: usize = 1;
-fn aiur_fn_417(
-  inp: [G; IN_417],
+const INPUT_SIZE_329: usize = 3;
+const IN_329: usize = 3;
+const OUT_329: usize = 1;
+fn aiur_fn_329(
+  inp: [G; IN_329],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_417], ExecError> {
+) -> Result<[G; OUT_329], 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_1.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_417] = [__v_0];
-        record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_329] = [__v_0];
+        record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } };
         let __v_3: G = __r_arr[0];
         let __v_4: G = { let __a_val = __v_2.as_canonical_u64(); let __b_val = __v_3.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_4.as_canonical_u64() {
           0u64 => {
-            let __ret: [G; OUT_417] = [__v_0];
-            record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_329] = [__v_0];
+            record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
-            let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } else { aiur_fn_418(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[330].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_330] = unsafe { *(result.output.as_ptr() as *const [G; OUT_330]) }; __ret } else { aiur_fn_330(__args, record, io_buffer, __cu)? } };
             let __v_5: G = __r_arr[0];
-            let __ret: [G; OUT_417] = [__v_5];
-            record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_329] = [__v_5];
+            record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -38084,15 +29820,15 @@ fn aiur_fn_417(
   })
 }
 
-const INPUT_SIZE_418: usize = 3;
-const IN_418: usize = 3;
-const OUT_418: usize = 1;
-fn aiur_fn_418(
-  inp: [G; IN_418],
+const INPUT_SIZE_330: usize = 3;
+const IN_330: usize = 3;
+const OUT_330: usize = 1;
+fn aiur_fn_330(
+  inp: [G; IN_330],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_418], ExecError> {
+) -> Result<[G; OUT_330], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -38107,8 +29843,8 @@ fn aiur_fn_418(
         let __v_7: 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_7.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_418] = [__v_0];
-            record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_330] = [__v_0];
+            record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
@@ -38116,8 +29852,8 @@ fn aiur_fn_418(
             let __v_9: G = (__v_4 - __v_1);
             let __v_10: G = G::from_u64(0);
             let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __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_418] = [__v_11];
-            record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_330] = [__v_11];
+            record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -38129,88 +29865,88 @@ fn aiur_fn_418(
         let __v_7: G = G::from_u64(1);
         let __v_8: G = G::from_u64(0);
         let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __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_418] = [__v_9];
-        record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_330] = [__v_9];
+        record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
         let __v_7: G = G::from_u64(2);
         let __v_8: G = G::from_u64(0);
         let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __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_418] = [__v_9];
-        record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_330] = [__v_9];
+        record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
         let __v_7: G = G::from_u64(3);
-        let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } else { aiur_fn_417(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } else { aiur_fn_329(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } else { aiur_fn_417(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } else { aiur_fn_329(__args, record, io_buffer, __cu)? } };
         let __v_9: G = __r_arr[0];
         let __v_10: G = G::from_u64(0);
         let __v_11: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __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_418] = [__v_11];
-        record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_330] = [__v_11];
+        record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       4u64 => {
         let __v_7: G = G::from_u64(4);
-        let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } else { aiur_fn_417(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } else { aiur_fn_329(__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_2 + __v_9);
-        let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } else { aiur_fn_417(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } else { aiur_fn_329(__args, record, io_buffer, __cu)? } };
         let __v_11: G = __r_arr[0];
         let __v_12: G = G::from_u64(0);
         let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __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_418] = [__v_13];
-        record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_330] = [__v_13];
+        record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       5u64 => {
         let __v_7: G = G::from_u64(5);
-        let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } else { aiur_fn_417(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } else { aiur_fn_329(__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_2 + __v_9);
-        let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } else { aiur_fn_417(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } else { aiur_fn_329(__args, record, io_buffer, __cu)? } };
         let __v_11: G = __r_arr[0];
         let __v_12: G = G::from_u64(0);
         let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __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_418] = [__v_13];
-        record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_330] = [__v_13];
+        record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       6u64 => {
         let __v_7: G = G::from_u64(6);
-        let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } else { aiur_fn_417(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } else { aiur_fn_329(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } else { aiur_fn_417(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } else { aiur_fn_329(__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_2 + __v_10);
-        let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_6, __v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } else { aiur_fn_417(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_6, __v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } else { aiur_fn_329(__args, record, io_buffer, __cu)? } };
         let __v_12: G = __r_arr[0];
         let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __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_418] = [__v_13];
-        record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_330] = [__v_13];
+        record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       7u64 => {
         let __v_7: G = G::from_u64(7);
         let __v_8: G = G::from_u64(0);
         let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __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_418] = [__v_9];
-        record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_330] = [__v_9];
+        record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       8u64 => {
         let __v_7: G = G::from_u64(8);
-        let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } else { aiur_fn_417(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } else { aiur_fn_329(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
         let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __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_418] = [__v_9];
-        record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_330] = [__v_9];
+        record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -38220,33 +29956,33 @@ fn aiur_fn_418(
   })
 }
 
-const INPUT_SIZE_419: usize = 3;
-const IN_419: usize = 3;
-const OUT_419: usize = 1;
-fn aiur_fn_419(
-  inp: [G; IN_419],
+const INPUT_SIZE_331: usize = 3;
+const IN_331: usize = 3;
+const OUT_331: usize = 1;
+fn aiur_fn_331(
+  inp: [G; IN_331],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_419], ExecError> {
+) -> Result<[G; OUT_331], 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_400] = { let __args: [G; IN_400] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
     let __v_4: G = { let __a_val = __v_2.as_canonical_u64(); let __b_val = __v_3.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_4.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_419] = [__v_0];
-        record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_331] = [__v_0];
+        record.function_queries[331].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } else { aiur_fn_420(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } else { aiur_fn_332(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
-        let __ret: [G; OUT_419] = [__v_5];
-        record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_331] = [__v_5];
+        record.function_queries[331].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -38256,15 +29992,15 @@ fn aiur_fn_419(
   })
 }
 
-const INPUT_SIZE_420: usize = 3;
-const IN_420: usize = 3;
-const OUT_420: usize = 1;
-fn aiur_fn_420(
-  inp: [G; IN_420],
+const INPUT_SIZE_332: usize = 3;
+const IN_332: usize = 3;
+const OUT_332: usize = 1;
+fn aiur_fn_332(
+  inp: [G; IN_332],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_420], ExecError> {
+) -> Result<[G; OUT_332], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -38276,90 +30012,90 @@ fn aiur_fn_420(
     let __v_6: G = __loaded[3];
     match __v_3.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[421].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_421] = unsafe { *(result.output.as_ptr() as *const [G; OUT_421]) }; __ret } else { aiur_fn_421(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } else { aiur_fn_333(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_420] = [__v_7];
-        record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_332] = [__v_7];
+        record.function_queries[332].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
         let __v_7: G = G::from_u64(1);
         let __v_8: G = G::from_u64(0);
         let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __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_420] = [__v_9];
-        record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_332] = [__v_9];
+        record.function_queries[332].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
         let __v_7: G = G::from_u64(2);
         let __v_8: G = G::from_u64(0);
         let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __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_420] = [__v_9];
-        record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_332] = [__v_9];
+        record.function_queries[332].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
         let __v_7: G = G::from_u64(3);
-        let __r_arr: [G; OUT_419] = { let __args: [G; IN_419] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[419].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_419] = unsafe { *(result.output.as_ptr() as *const [G; OUT_419]) }; __ret } else { aiur_fn_419(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[331].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_331] = unsafe { *(result.output.as_ptr() as *const [G; OUT_331]) }; __ret } else { aiur_fn_331(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_419] = { let __args: [G; IN_419] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[419].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_419] = unsafe { *(result.output.as_ptr() as *const [G; OUT_419]) }; __ret } else { aiur_fn_419(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[331].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_331] = unsafe { *(result.output.as_ptr() as *const [G; OUT_331]) }; __ret } else { aiur_fn_331(__args, record, io_buffer, __cu)? } };
         let __v_9: G = __r_arr[0];
         let __v_10: G = G::from_u64(0);
         let __v_11: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __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_420] = [__v_11];
-        record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_332] = [__v_11];
+        record.function_queries[332].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       4u64 => {
         let __v_7: G = G::from_u64(4);
-        let __r_arr: [G; OUT_419] = { let __args: [G; IN_419] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[419].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_419] = unsafe { *(result.output.as_ptr() as *const [G; OUT_419]) }; __ret } else { aiur_fn_419(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[331].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_331] = unsafe { *(result.output.as_ptr() as *const [G; OUT_331]) }; __ret } else { aiur_fn_331(__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_2 + __v_9);
-        let __r_arr: [G; OUT_419] = { let __args: [G; IN_419] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[419].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_419] = unsafe { *(result.output.as_ptr() as *const [G; OUT_419]) }; __ret } else { aiur_fn_419(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[331].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_331] = unsafe { *(result.output.as_ptr() as *const [G; OUT_331]) }; __ret } else { aiur_fn_331(__args, record, io_buffer, __cu)? } };
         let __v_11: G = __r_arr[0];
         let __v_12: G = G::from_u64(0);
         let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __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_420] = [__v_13];
-        record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_332] = [__v_13];
+        record.function_queries[332].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       5u64 => {
         let __v_7: G = G::from_u64(5);
-        let __r_arr: [G; OUT_419] = { let __args: [G; IN_419] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[419].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_419] = unsafe { *(result.output.as_ptr() as *const [G; OUT_419]) }; __ret } else { aiur_fn_419(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[331].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_331] = unsafe { *(result.output.as_ptr() as *const [G; OUT_331]) }; __ret } else { aiur_fn_331(__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_2 + __v_9);
-        let __r_arr: [G; OUT_419] = { let __args: [G; IN_419] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[419].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_419] = unsafe { *(result.output.as_ptr() as *const [G; OUT_419]) }; __ret } else { aiur_fn_419(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[331].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_331] = unsafe { *(result.output.as_ptr() as *const [G; OUT_331]) }; __ret } else { aiur_fn_331(__args, record, io_buffer, __cu)? } };
         let __v_11: G = __r_arr[0];
         let __v_12: G = G::from_u64(0);
         let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __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_420] = [__v_13];
-        record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_332] = [__v_13];
+        record.function_queries[332].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       6u64 => {
-        let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[422].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_422] = unsafe { *(result.output.as_ptr() as *const [G; OUT_422]) }; __ret } else { aiur_fn_422(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } else { aiur_fn_334(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_420] = [__v_7];
-        record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_332] = [__v_7];
+        record.function_queries[332].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       7u64 => {
         let __v_7: G = G::from_u64(7);
         let __v_8: G = G::from_u64(0);
         let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __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_420] = [__v_9];
-        record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_332] = [__v_9];
+        record.function_queries[332].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       8u64 => {
         let __v_7: G = G::from_u64(8);
-        let __r_arr: [G; OUT_419] = { let __args: [G; IN_419] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[419].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_419] = unsafe { *(result.output.as_ptr() as *const [G; OUT_419]) }; __ret } else { aiur_fn_419(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[331].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_331] = unsafe { *(result.output.as_ptr() as *const [G; OUT_331]) }; __ret } else { aiur_fn_331(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
         let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __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_420] = [__v_9];
-        record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_332] = [__v_9];
+        record.function_queries[332].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -38369,15 +30105,15 @@ fn aiur_fn_420(
   })
 }
 
-const INPUT_SIZE_421: usize = 3;
-const IN_421: usize = 3;
-const OUT_421: usize = 1;
-fn aiur_fn_421(
-  inp: [G; IN_421],
+const INPUT_SIZE_333: usize = 3;
+const IN_333: usize = 3;
+const OUT_333: usize = 1;
+fn aiur_fn_333(
+  inp: [G; IN_333],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_421], ExecError> {
+) -> Result<[G; OUT_333], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -38388,8 +30124,8 @@ fn aiur_fn_421(
         let __v_4: G = G::from_u64(0);
         let __v_5: G = G::from_u64(0);
         let __v_6: G = { let __values: [G; 4] = [__v_4, __v_0, __v_5, __v_5]; 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_421] = [__v_6];
-        record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_333] = [__v_6];
+        record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -38397,10 +30133,10 @@ fn aiur_fn_421(
         match __v_4.as_canonical_u64() {
           0u64 => {
             let __v_5: G = G::from_u64(0);
-            let __r_arr: [G; OUT_413] = { let __args: [G; IN_413] = [__v_1, __v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[413].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_413] = unsafe { *(result.output.as_ptr() as *const [G; OUT_413]) }; __ret } else { aiur_fn_413(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_1, __v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[325].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_325] = unsafe { *(result.output.as_ptr() as *const [G; OUT_325]) }; __ret } else { aiur_fn_325(__args, record, io_buffer, __cu)? } };
             let __v_6: G = __r_arr[0];
-            let __ret: [G; OUT_421] = [__v_6];
-            record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_333] = [__v_6];
+            record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -38409,8 +30145,8 @@ fn aiur_fn_421(
             let __v_7: G = (__v_0 - __v_6);
             let __v_8: G = G::from_u64(0);
             let __v_9: G = { let __values: [G; 4] = [__v_5, __v_7, __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_421] = [__v_9];
-            record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_333] = [__v_9];
+            record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -38422,15 +30158,15 @@ fn aiur_fn_421(
   })
 }
 
-const INPUT_SIZE_422: usize = 5;
-const IN_422: usize = 5;
-const OUT_422: usize = 1;
-fn aiur_fn_422(
-  inp: [G; IN_422],
+const INPUT_SIZE_334: usize = 5;
+const IN_334: usize = 5;
+const OUT_334: usize = 1;
+fn aiur_fn_334(
+  inp: [G; IN_334],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_422], ExecError> {
+) -> Result<[G; OUT_334], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -38438,48 +30174,48 @@ fn aiur_fn_422(
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
     let __v_5: G = G::from_u64(6);
-    let __r_arr: [G; OUT_419] = { let __args: [G; IN_419] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[419].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_419] = unsafe { *(result.output.as_ptr() as *const [G; OUT_419]) }; __ret } else { aiur_fn_419(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[331].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_331] = unsafe { *(result.output.as_ptr() as *const [G; OUT_331]) }; __ret } else { aiur_fn_331(__args, record, io_buffer, __cu)? } };
     let __v_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_419] = { let __args: [G; IN_419] = [__v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[419].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_419] = unsafe { *(result.output.as_ptr() as *const [G; OUT_419]) }; __ret } else { aiur_fn_419(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[331].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_331] = unsafe { *(result.output.as_ptr() as *const [G; OUT_331]) }; __ret } else { aiur_fn_331(__args, record, io_buffer, __cu)? } };
     let __v_7: G = __r_arr[0];
     let __v_8: G = G::from_u64(1);
     let __v_9: G = (__v_4 + __v_8);
-    let __r_arr: [G; OUT_419] = { let __args: [G; IN_419] = [__v_2, __v_3, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[419].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_419] = unsafe { *(result.output.as_ptr() as *const [G; OUT_419]) }; __ret } else { aiur_fn_419(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_2, __v_3, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[331].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_331] = unsafe { *(result.output.as_ptr() as *const [G; OUT_331]) }; __ret } else { aiur_fn_331(__args, record, io_buffer, __cu)? } };
     let __v_10: G = __r_arr[0];
     let __v_11: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __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_422] = [__v_11];
-    record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_334] = [__v_11];
+    record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_423: usize = 3;
-const IN_423: usize = 3;
-const OUT_423: usize = 1;
-fn aiur_fn_423(
-  inp: [G; IN_423],
+const INPUT_SIZE_335: usize = 3;
+const IN_335: usize = 3;
+const OUT_335: usize = 1;
+fn aiur_fn_335(
+  inp: [G; IN_335],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_423], ExecError> {
+) -> Result<[G; OUT_335], 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_400] = { let __args: [G; IN_400] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
     let __v_4: G = { let __a_val = __v_2.as_canonical_u64(); let __b_val = __v_3.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_4.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_423] = [__v_0];
-        record.function_queries[423].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_335] = [__v_0];
+        record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[425].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_425] = unsafe { *(result.output.as_ptr() as *const [G; OUT_425]) }; __ret } else { aiur_fn_425(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
-        let __ret: [G; OUT_423] = [__v_5];
-        record.function_queries[423].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_335] = [__v_5];
+        record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -38489,32 +30225,32 @@ fn aiur_fn_423(
   })
 }
 
-const INPUT_SIZE_424: usize = 3;
-const IN_424: usize = 3;
-const OUT_424: usize = 1;
-fn aiur_fn_424(
-  inp: [G; IN_424],
+const INPUT_SIZE_336: usize = 3;
+const IN_336: usize = 3;
+const OUT_336: usize = 1;
+fn aiur_fn_336(
+  inp: [G; IN_336],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_424], ExecError> {
+) -> Result<[G; OUT_336], 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_187] = { let __args: [G; IN_187] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } else { aiur_fn_711(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
     let __v_4: G = (__v_0 - __v_2);
     let __v_5: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_3.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() {
       1u64 => {
-        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
         let __v_7: G = G::from_u64(0);
-        let __r_arr: [G; OUT_413] = { let __args: [G; IN_413] = [__v_6, __v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[413].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_413] = unsafe { *(result.output.as_ptr() as *const [G; OUT_413]) }; __ret } else { aiur_fn_413(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_6, __v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[325].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_325] = unsafe { *(result.output.as_ptr() as *const [G; OUT_325]) }; __ret } else { aiur_fn_325(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
-        let __ret: [G; OUT_424] = [__v_8];
-        record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_336] = [__v_8];
+        record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -38522,8 +30258,8 @@ fn aiur_fn_424(
         let __v_7: G = (__v_0 - __v_3);
         let __v_8: G = G::from_u64(0);
         let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __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_424] = [__v_9];
-        record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_336] = [__v_9];
+        record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -38533,15 +30269,15 @@ fn aiur_fn_424(
   })
 }
 
-const INPUT_SIZE_425: usize = 3;
-const IN_425: usize = 3;
-const OUT_425: usize = 1;
-fn aiur_fn_425(
-  inp: [G; IN_425],
+const INPUT_SIZE_337: usize = 3;
+const IN_337: usize = 3;
+const OUT_337: usize = 1;
+fn aiur_fn_337(
+  inp: [G; IN_337],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_425], ExecError> {
+) -> Result<[G; OUT_337], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -38553,90 +30289,90 @@ fn aiur_fn_425(
     let __v_6: G = __loaded[3];
     match __v_3.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[424].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_424] = unsafe { *(result.output.as_ptr() as *const [G; OUT_424]) }; __ret } else { aiur_fn_424(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } else { aiur_fn_336(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_425] = [__v_7];
-        record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_337] = [__v_7];
+        record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
         let __v_7: G = G::from_u64(1);
         let __v_8: G = G::from_u64(0);
         let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __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_425] = [__v_9];
-        record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_337] = [__v_9];
+        record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
         let __v_7: G = G::from_u64(2);
         let __v_8: G = G::from_u64(0);
         let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __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_425] = [__v_9];
-        record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_337] = [__v_9];
+        record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
         let __v_7: G = G::from_u64(3);
-        let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[423].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_423] = unsafe { *(result.output.as_ptr() as *const [G; OUT_423]) }; __ret } else { aiur_fn_423(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } else { aiur_fn_335(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[423].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_423] = unsafe { *(result.output.as_ptr() as *const [G; OUT_423]) }; __ret } else { aiur_fn_423(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } else { aiur_fn_335(__args, record, io_buffer, __cu)? } };
         let __v_9: G = __r_arr[0];
         let __v_10: G = G::from_u64(0);
         let __v_11: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __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_425] = [__v_11];
-        record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_337] = [__v_11];
+        record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       4u64 => {
         let __v_7: G = G::from_u64(4);
-        let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[423].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_423] = unsafe { *(result.output.as_ptr() as *const [G; OUT_423]) }; __ret } else { aiur_fn_423(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } else { aiur_fn_335(__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_2 + __v_9);
-        let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[423].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_423] = unsafe { *(result.output.as_ptr() as *const [G; OUT_423]) }; __ret } else { aiur_fn_423(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } else { aiur_fn_335(__args, record, io_buffer, __cu)? } };
         let __v_11: G = __r_arr[0];
         let __v_12: G = G::from_u64(0);
         let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __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_425] = [__v_13];
-        record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_337] = [__v_13];
+        record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       5u64 => {
         let __v_7: G = G::from_u64(5);
-        let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[423].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_423] = unsafe { *(result.output.as_ptr() as *const [G; OUT_423]) }; __ret } else { aiur_fn_423(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } else { aiur_fn_335(__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_2 + __v_9);
-        let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[423].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_423] = unsafe { *(result.output.as_ptr() as *const [G; OUT_423]) }; __ret } else { aiur_fn_423(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } else { aiur_fn_335(__args, record, io_buffer, __cu)? } };
         let __v_11: G = __r_arr[0];
         let __v_12: G = G::from_u64(0);
         let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __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_425] = [__v_13];
-        record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_337] = [__v_13];
+        record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       6u64 => {
-        let __r_arr: [G; OUT_426] = { let __args: [G; IN_426] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[426].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_426] = unsafe { *(result.output.as_ptr() as *const [G; OUT_426]) }; __ret } else { aiur_fn_426(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } else { aiur_fn_338(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_425] = [__v_7];
-        record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_337] = [__v_7];
+        record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       7u64 => {
         let __v_7: G = G::from_u64(7);
         let __v_8: G = G::from_u64(0);
         let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __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_425] = [__v_9];
-        record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_337] = [__v_9];
+        record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       8u64 => {
         let __v_7: G = G::from_u64(8);
-        let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[423].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_423] = unsafe { *(result.output.as_ptr() as *const [G; OUT_423]) }; __ret } else { aiur_fn_423(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } else { aiur_fn_335(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
         let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __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_425] = [__v_9];
-        record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_337] = [__v_9];
+        record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -38646,15 +30382,15 @@ fn aiur_fn_425(
   })
 }
 
-const INPUT_SIZE_426: usize = 5;
-const IN_426: usize = 5;
-const OUT_426: usize = 1;
-fn aiur_fn_426(
-  inp: [G; IN_426],
+const INPUT_SIZE_338: usize = 5;
+const IN_338: usize = 5;
+const OUT_338: usize = 1;
+fn aiur_fn_338(
+  inp: [G; IN_338],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_426], ExecError> {
+) -> Result<[G; OUT_338], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -38662,69 +30398,30 @@ fn aiur_fn_426(
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
     let __v_5: G = G::from_u64(6);
-    let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[423].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_423] = unsafe { *(result.output.as_ptr() as *const [G; OUT_423]) }; __ret } else { aiur_fn_423(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } else { aiur_fn_335(__args, record, io_buffer, __cu)? } };
     let __v_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[423].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_423] = unsafe { *(result.output.as_ptr() as *const [G; OUT_423]) }; __ret } else { aiur_fn_423(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } else { aiur_fn_335(__args, record, io_buffer, __cu)? } };
     let __v_7: G = __r_arr[0];
     let __v_8: G = G::from_u64(1);
     let __v_9: G = (__v_4 + __v_8);
-    let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_2, __v_3, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[423].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_423] = unsafe { *(result.output.as_ptr() as *const [G; OUT_423]) }; __ret } else { aiur_fn_423(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_2, __v_3, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } else { aiur_fn_335(__args, record, io_buffer, __cu)? } };
     let __v_10: G = __r_arr[0];
     let __v_11: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __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_426] = [__v_11];
-    record.function_queries[426].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_338] = [__v_11];
+    record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_427: usize = 2;
-const IN_427: usize = 2;
-const OUT_427: usize = 1;
-fn aiur_fn_427(
-  inp: [G; IN_427],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_427], 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_427] = [__v_0];
-        record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __v_5: G = G::from_u64(3);
-        let __v_6: G = G::from_u64(0);
-        let __v_7: G = { let __values: [G; 4] = [__v_5, __v_0, __v_3, __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 __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_7, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[427].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_427] = unsafe { *(result.output.as_ptr() as *const [G; OUT_427]) }; __ret } else { aiur_fn_427(__args, record, io_buffer, __cu)? } };
-        let __v_8: G = __r_arr[0];
-        let __ret: [G; OUT_427] = [__v_8];
-        record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_428: usize = 3;
-const IN_428: usize = 3;
-const OUT_428: usize = 3;
-fn aiur_fn_428(
-  inp: [G; IN_428],
+const INPUT_SIZE_339: usize = 3;
+const IN_339: usize = 3;
+const OUT_339: usize = 3;
+fn aiur_fn_339(
+  inp: [G; IN_339],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_428], ExecError> {
+) -> Result<[G; OUT_339], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -38744,17 +30441,17 @@ fn aiur_fn_428(
           0u64 => {
             let __v_10: G = G::from_u64(0);
             let __v_11: G = { let __values: [G; 3] = [__v_10, __v_8, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_428] = { let __args: [G; IN_428] = [__v_5, __v_9, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[428].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_428] = unsafe { *(result.output.as_ptr() as *const [G; OUT_428]) }; __ret } else { aiur_fn_428(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_5, __v_9, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = unsafe { *(result.output.as_ptr() as *const [G; OUT_339]) }; __ret } else { aiur_fn_339(__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 __ret: [G; OUT_428] = [__v_12, __v_13, __v_14];
-            record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_339] = [__v_12, __v_13, __v_14];
+            record.function_queries[339].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           1u64 => {
-            let __ret: [G; OUT_428] = [__v_0, __v_2, __v_1];
-            record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_339] = [__v_0, __v_2, __v_1];
+            record.function_queries[339].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -38763,432 +30460,601 @@ fn aiur_fn_428(
         }
       },
       _ => {
-        let __ret: [G; OUT_428] = [__v_0, __v_2, __v_1];
-        record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_339] = [__v_0, __v_2, __v_1];
+        record.function_queries[339].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_429: usize = 5;
-const IN_429: usize = 5;
-const OUT_429: usize = 1;
-fn aiur_fn_429(
-  inp: [G; IN_429],
+const INPUT_SIZE_340: usize = 3;
+const IN_340: usize = 3;
+const OUT_340: usize = 1;
+fn aiur_fn_340(
+  inp: [G; IN_340],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_429], ExecError> {
+) -> Result<[G; OUT_340], 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(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 __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_1, __v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[428].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_428] = unsafe { *(result.output.as_ptr() as *const [G; OUT_428]) }; __ret } else { aiur_fn_428(__args, record, io_buffer, __cu)? } };
-    let __v_8: G = __r_arr[0];
-    let __v_9: G = __r_arr[1];
-    let __v_10: G = __r_arr[2];
-    let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { 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_11: G = __r_arr[0];
-    match __v_11.as_canonical_u64() {
+    let __v_3: G = G::from_u64(1);
+    let __v_4: G = G::from_u64(1);
+    let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __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 __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_1, __v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = unsafe { *(result.output.as_ptr() as *const [G; OUT_339]) }; __ret } else { aiur_fn_339(__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 __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } else { aiur_fn_711(__args, record, io_buffer, __cu)? } };
+    let __v_9: G = __r_arr[0];
+    match __v_9.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_1, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[427].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_427] = unsafe { *(result.output.as_ptr() as *const [G; OUT_427]) }; __ret } else { aiur_fn_427(__args, record, io_buffer, __cu)? } };
-        let __v_12: G = __r_arr[0];
-        let __ret: [G; OUT_429] = [__v_12];
-        record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_1, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } };
+        let __v_10: G = __r_arr[0];
+        let __ret: [G; OUT_340] = [__v_10];
+        record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
+        let __v_10: G = G::from_u64(0);
+        let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } };
+        let __v_11: G = __r_arr[0];
         let __v_12: G = G::from_u64(0);
-        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_9, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_6, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[331].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_331] = unsafe { *(result.output.as_ptr() as *const [G; OUT_331]) }; __ret } else { aiur_fn_331(__args, record, io_buffer, __cu)? } };
         let __v_13: G = __r_arr[0];
-        let __v_14: G = G::from_u64(0);
-        let __r_arr: [G; OUT_419] = { let __args: [G; IN_419] = [__v_8, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[419].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_419] = unsafe { *(result.output.as_ptr() as *const [G; OUT_419]) }; __ret } else { aiur_fn_419(__args, record, io_buffer, __cu)? } };
-        let __v_15: G = __r_arr[0];
-        let __r_arr: [G; OUT_430] = { let __args: [G; IN_430] = [__v_15, __v_10, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[430].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_430] = unsafe { *(result.output.as_ptr() as *const [G; OUT_430]) }; __ret } else { aiur_fn_430(__args, record, io_buffer, __cu)? } };
-        let __v_16: G = __r_arr[0];
-        let __ret: [G; OUT_429] = [__v_16];
-        record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_13, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } else { aiur_fn_341(__args, record, io_buffer, __cu)? } };
+        let __v_14: G = __r_arr[0];
+        let __ret: [G; OUT_340] = [__v_14];
+        record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __v_12: G = G::from_u64(0);
-        let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_8, __v_9, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[423].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_423] = unsafe { *(result.output.as_ptr() as *const [G; OUT_423]) }; __ret } else { aiur_fn_423(__args, record, io_buffer, __cu)? } };
-        let __v_13: G = __r_arr[0];
-        let __r_arr: [G; OUT_430] = { let __args: [G; IN_430] = [__v_13, __v_10, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[430].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_430] = unsafe { *(result.output.as_ptr() as *const [G; OUT_430]) }; __ret } else { aiur_fn_430(__args, record, io_buffer, __cu)? } };
-        let __v_14: G = __r_arr[0];
-        let __ret: [G; OUT_429] = [__v_14];
-        record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __v_10: G = G::from_u64(0);
+        let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_6, __v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } else { aiur_fn_335(__args, record, io_buffer, __cu)? } };
+        let __v_11: G = __r_arr[0];
+        let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_11, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } else { aiur_fn_341(__args, record, io_buffer, __cu)? } };
+        let __v_12: G = __r_arr[0];
+        let __ret: [G; OUT_340] = [__v_12];
+        record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_430: usize = 5;
-const IN_430: usize = 5;
-const OUT_430: usize = 1;
-fn aiur_fn_430(
-  inp: [G; IN_430],
+const INPUT_SIZE_341: usize = 3;
+const IN_341: usize = 3;
+const OUT_341: usize = 1;
+fn aiur_fn_341(
+  inp: [G; IN_341],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_430], ExecError> {
+) -> Result<[G; OUT_341], 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 __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_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() {
+    let __v_3: G = __loaded[0];
+    let __v_4: G = __loaded[1];
+    let __v_5: G = __loaded[2];
+    let __v_6: G = __loaded[3];
+    match __v_3.as_canonical_u64() {
       3u64 => {
-        let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[189].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_189] = unsafe { *(result.output.as_ptr() as *const [G; OUT_189]) }; __ret } else { aiur_fn_189(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[106].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_106] = unsafe { *(result.output.as_ptr() as *const [G; OUT_106]) }; __ret } else { aiur_fn_106(__args, record, io_buffer, __cu)? } };
+        let __v_7: G = __r_arr[0];
+        let __v_8: G = __r_arr[1];
+        let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[710].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_710] = unsafe { *(result.output.as_ptr() as *const [G; OUT_710]) }; __ret } else { aiur_fn_710(__args, record, io_buffer, __cu)? } };
         let __v_9: G = __r_arr[0];
-        let __v_10: G = __r_arr[1];
-        let __r_arr: [G; OUT_773] = { let __args: [G; IN_773] = [__v_10, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[773].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_773] = unsafe { *(result.output.as_ptr() as *const [G; OUT_773]) }; __ret } else { aiur_fn_773(__args, record, io_buffer, __cu)? } };
-        let __v_11: G = __r_arr[0];
-        let __r_arr: [G; OUT_430] = { let __args: [G; IN_430] = [__v_9, __v_11, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[430].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_430] = unsafe { *(result.output.as_ptr() as *const [G; OUT_430]) }; __ret } else { aiur_fn_430(__args, record, io_buffer, __cu)? } };
-        let __v_12: G = __r_arr[0];
-        let __ret: [G; OUT_430] = [__v_12];
-        record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_7, __v_9, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } else { aiur_fn_341(__args, record, io_buffer, __cu)? } };
+        let __v_10: G = __r_arr[0];
+        let __ret: [G; OUT_341] = [__v_10];
+        record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       4u64 => {
-        let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_1, __v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } else { aiur_fn_429(__args, record, io_buffer, __cu)? } };
-        let __v_9: G = __r_arr[0];
-        let __ret: [G; OUT_430] = [__v_9];
-        record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } else { aiur_fn_340(__args, record, io_buffer, __cu)? } };
+        let __v_7: G = __r_arr[0];
+        let __ret: [G; OUT_341] = [__v_7];
+        record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_6, __v_7, __v_0, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[432].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_432] = unsafe { *(result.output.as_ptr() as *const [G; OUT_432]) }; __ret } else { aiur_fn_432(__args, record, io_buffer, __cu)? } };
-        let __v_9: G = __r_arr[0];
-        let __ret: [G; OUT_430] = [__v_9];
-        record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_357] = { let __args: [G; IN_357] = [__v_4, __v_5, __v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[357].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_357] = unsafe { *(result.output.as_ptr() as *const [G; OUT_357]) }; __ret } else { aiur_fn_357(__args, record, io_buffer, __cu)? } };
+        let __v_7: G = __r_arr[0];
+        let __ret: [G; OUT_341] = [__v_7];
+        record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       6u64 => {
-        let __v_9: G = G::from_u64(0);
-        let __r_arr: [G; OUT_419] = { let __args: [G; IN_419] = [__v_8, __v_7, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[419].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_419] = unsafe { *(result.output.as_ptr() as *const [G; OUT_419]) }; __ret } else { aiur_fn_419(__args, record, io_buffer, __cu)? } };
-        let __v_10: G = __r_arr[0];
-        let __r_arr: [G; OUT_430] = { let __args: [G; IN_430] = [__v_10, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[430].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_430] = unsafe { *(result.output.as_ptr() as *const [G; OUT_430]) }; __ret } else { aiur_fn_430(__args, record, io_buffer, __cu)? } };
-        let __v_11: G = __r_arr[0];
-        let __ret: [G; OUT_430] = [__v_11];
-        record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __v_7: G = G::from_u64(0);
+        let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_6, __v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[331].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_331] = unsafe { *(result.output.as_ptr() as *const [G; OUT_331]) }; __ret } else { aiur_fn_331(__args, record, io_buffer, __cu)? } };
+        let __v_8: G = __r_arr[0];
+        let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } else { aiur_fn_341(__args, record, io_buffer, __cu)? } };
+        let __v_9: G = __r_arr[0];
+        let __ret: [G; OUT_341] = [__v_9];
+        record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       8u64 => {
-        let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_6, __v_7, __v_8, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[431].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_431] = unsafe { *(result.output.as_ptr() as *const [G; OUT_431]) }; __ret } else { aiur_fn_431(__args, record, io_buffer, __cu)? } };
-        let __v_9: G = __r_arr[0];
-        let __ret: [G; OUT_430] = [__v_9];
-        record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } };
+        let __v_7: G = __r_arr[0];
+        let __ret: [G; OUT_341] = [__v_7];
+        record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[427].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_427] = unsafe { *(result.output.as_ptr() as *const [G; OUT_427]) }; __ret } else { aiur_fn_427(__args, record, io_buffer, __cu)? } };
-        let __v_9: G = __r_arr[0];
-        let __ret: [G; OUT_430] = [__v_9];
-        record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } };
+        let __v_7: G = __r_arr[0];
+        let __ret: [G; OUT_341] = [__v_7];
+        record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_431: usize = 7;
-const IN_431: usize = 7;
-const OUT_431: usize = 1;
-fn aiur_fn_431(
-  inp: [G; IN_431],
+const INPUT_SIZE_342: usize = 5;
+const IN_342: usize = 5;
+const OUT_342: usize = 1;
+fn aiur_fn_342(
+  inp: [G; IN_342],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_431], ExecError> {
+) -> Result<[G; OUT_342], 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 __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_2, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = unsafe { *(result.output.as_ptr() as *const [G; OUT_377]) }; __ret } else { aiur_fn_377(__args, record, io_buffer, __cu)? } };
+    let __v_5: G = __r_arr[0];
+    let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_5, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { 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_6: G = __r_arr[0];
+    let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[106].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_106] = unsafe { *(result.output.as_ptr() as *const [G; OUT_106]) }; __ret } else { aiur_fn_106(__args, record, io_buffer, __cu)? } };
     let __v_7: G = __r_arr[0];
-    let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_7, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = unsafe { *(result.output.as_ptr() as *const [G; OUT_396]) }; __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } };
-    let __v_8: G = __r_arr[0];
-    let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[189].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_189] = unsafe { *(result.output.as_ptr() as *const [G; OUT_189]) }; __ret } else { aiur_fn_189(__args, record, io_buffer, __cu)? } };
+    let __v_8: G = __r_arr[1];
+    let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_0, __v_1, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[346].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_346] = unsafe { *(result.output.as_ptr() as *const [G; OUT_346]) }; __ret } else { aiur_fn_346(__args, record, io_buffer, __cu)? } };
     let __v_9: G = __r_arr[0];
     let __v_10: G = __r_arr[1];
-    let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_0, __v_1, __v_9, __v_10, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[398].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_398] = unsafe { *(result.output.as_ptr() as *const [G; OUT_398]) }; __ret } else { aiur_fn_398(__args, record, io_buffer, __cu)? } };
-    let __v_11: G = __r_arr[0];
-    let __v_12: G = __r_arr[1];
-    match __v_11.as_canonical_u64() {
+    match __v_9.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_430] = { let __args: [G; IN_430] = [__v_12, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[430].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_430] = unsafe { *(result.output.as_ptr() as *const [G; OUT_430]) }; __ret } else { aiur_fn_430(__args, record, io_buffer, __cu)? } };
-        let __v_13: G = __r_arr[0];
-        let __ret: [G; OUT_431] = [__v_13];
-        record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_10, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } else { aiur_fn_341(__args, record, io_buffer, __cu)? } };
+        let __v_11: G = __r_arr[0];
+        let __ret: [G; OUT_342] = [__v_11];
+        record.function_queries[342].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_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: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
-        let __v_13: G = __loaded[0];
-        let __v_14: G = __loaded[1];
-        let __v_15: G = __loaded[2];
-        let __v_16: G = __loaded[3];
-        match __v_13.as_canonical_u64() {
+      _ => {
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; 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: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].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];
+        match __v_11.as_canonical_u64() {
           2u64 => {
-            let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_5, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-            let __v_17: G = __r_arr[0];
-            let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_17.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].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];
-            let __v_22: G = __loaded[4];
-            let __v_23: G = __loaded[5];
-            let __v_24: G = __loaded[6];
-            let __v_25: G = __loaded[7];
-            let __v_26: G = __loaded[8];
-            let __v_27: G = __loaded[9];
-            let __v_28: G = __loaded[10];
-            match __v_18.as_canonical_u64() {
+            let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[347].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_347] = unsafe { *(result.output.as_ptr() as *const [G; OUT_347]) }; __ret } else { aiur_fn_347(__args, record, io_buffer, __cu)? } };
+            let __v_15: G = __r_arr[0];
+            let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; 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: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+            let __v_16: G = __loaded[0];
+            let __v_17: G = __loaded[1];
+            let __v_18: G = __loaded[2];
+            let __v_19: G = __loaded[3];
+            let __v_20: G = __loaded[4];
+            let __v_21: G = __loaded[5];
+            let __v_22: G = __loaded[6];
+            let __v_23: G = __loaded[7];
+            let __v_24: G = __loaded[8];
+            let __v_25: G = __loaded[9];
+            let __v_26: G = __loaded[10];
+            let __v_27: G = __loaded[11];
+            match __v_16.as_canonical_u64() {
               6u64 => {
-                let __v_29: G = (__v_23 + __v_1);
-                let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_10, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[455].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_455] = unsafe { *(result.output.as_ptr() as *const [G; OUT_455]) }; __ret } else { aiur_fn_455(__args, record, io_buffer, __cu)? } };
+                let __v_28: G = (__v_22 + __v_1);
+                let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_8, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } };
+                let __v_29: G = __r_arr[0];
+                let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_29, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } else { aiur_fn_341(__args, record, io_buffer, __cu)? } };
                 let __v_30: G = __r_arr[0];
-                let __r_arr: [G; OUT_430] = { let __args: [G; IN_430] = [__v_30, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[430].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_430] = unsafe { *(result.output.as_ptr() as *const [G; OUT_430]) }; __ret } else { aiur_fn_430(__args, record, io_buffer, __cu)? } };
-                let __v_31: G = __r_arr[0];
-                let __ret: [G; OUT_431] = [__v_31];
-                record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_342] = [__v_30];
+                record.function_queries[342].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                let __v_29: G = G::from_u64(8);
-                let __v_30: G = { let __values: [G; 4] = [__v_29, __v_0, __v_1, __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 __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_30, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[427].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_427] = unsafe { *(result.output.as_ptr() as *const [G; OUT_427]) }; __ret } else { aiur_fn_427(__args, record, io_buffer, __cu)? } };
-                let __v_31: G = __r_arr[0];
-                let __ret: [G; OUT_431] = [__v_31];
-                record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __v_28: G = G::from_u64(8);
+                let __v_29: G = { let __values: [G; 4] = [__v_28, __v_0, __v_1, __v_5]; 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_228] = { let __args: [G; IN_228] = [__v_29, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } };
+                let __v_30: G = __r_arr[0];
+                let __ret: [G; OUT_342] = [__v_30];
+                record.function_queries[342].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
           _ => {
-            let __v_17: G = G::from_u64(8);
-            let __v_18: G = { let __values: [G; 4] = [__v_17, __v_0, __v_1, __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 __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_18, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[427].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_427] = unsafe { *(result.output.as_ptr() as *const [G; OUT_427]) }; __ret } else { aiur_fn_427(__args, record, io_buffer, __cu)? } };
-            let __v_19: G = __r_arr[0];
-            let __ret: [G; OUT_431] = [__v_19];
-            record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __v_15: G = G::from_u64(8);
+            let __v_16: G = { let __values: [G; 4] = [__v_15, __v_0, __v_1, __v_5]; 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_228] = { let __args: [G; IN_228] = [__v_16, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } };
+            let __v_17: G = __r_arr[0];
+            let __ret: [G; OUT_342] = [__v_17];
+            record.function_queries[342].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64()));
-      },
     }
   })
 }
 
-const INPUT_SIZE_432: usize = 7;
-const IN_432: usize = 7;
-const OUT_432: usize = 1;
-fn aiur_fn_432(
-  inp: [G; IN_432],
+const INPUT_SIZE_343: usize = 0;
+const IN_343: usize = 0;
+const OUT_343: usize = 1;
+fn aiur_fn_343(
+  inp: [G; IN_343],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_432], ExecError> {
+) -> Result<[G; OUT_343], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = G::from_u64(116);
+    let __v_1: G = G::from_u64(89);
+    let __v_2: G = G::from_u64(54);
+    let __v_3: G = G::from_u64(252);
+    let __v_4: G = G::from_u64(185);
+    let __v_5: G = G::from_u64(216);
+    let __v_6: G = G::from_u64(108);
+    let __v_7: G = G::from_u64(68);
+    let __v_8: G = G::from_u64(87);
+    let __v_9: G = G::from_u64(240);
+    let __v_10: G = G::from_u64(253);
+    let __v_11: G = G::from_u64(30);
+    let __v_12: G = G::from_u64(83);
+    let __v_13: G = G::from_u64(126);
+    let __v_14: G = G::from_u64(103);
+    let __v_15: G = G::from_u64(7);
+    let __v_16: G = G::from_u64(127);
+    let __v_17: G = G::from_u64(70);
+    let __v_18: G = G::from_u64(247);
+    let __v_19: G = G::from_u64(132);
+    let __v_20: G = G::from_u64(17);
+    let __v_21: G = G::from_u64(8);
+    let __v_22: G = G::from_u64(65);
+    let __v_23: G = G::from_u64(157);
+    let __v_24: G = G::from_u64(172);
+    let __v_25: G = G::from_u64(121);
+    let __v_26: G = G::from_u64(132);
+    let __v_27: G = G::from_u64(0);
+    let __v_28: G = G::from_u64(139);
+    let __v_29: G = G::from_u64(86);
+    let __v_30: G = G::from_u64(91);
+    let __v_31: G = G::from_u64(151);
+    let __v_32: G = { let __values: [G; 32] = [__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]; 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_343] = [__v_32];
+    record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_344: usize = 0;
+const IN_344: usize = 0;
+const OUT_344: usize = 1;
+fn aiur_fn_344(
+  inp: [G; IN_344],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_344], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = G::from_u64(171);
+    let __v_1: G = G::from_u64(55);
+    let __v_2: G = G::from_u64(118);
+    let __v_3: G = G::from_u64(152);
+    let __v_4: G = G::from_u64(87);
+    let __v_5: G = G::from_u64(67);
+    let __v_6: G = G::from_u64(175);
+    let __v_7: G = G::from_u64(19);
+    let __v_8: G = G::from_u64(169);
+    let __v_9: G = G::from_u64(203);
+    let __v_10: G = G::from_u64(26);
+    let __v_11: G = G::from_u64(125);
+    let __v_12: G = G::from_u64(47);
+    let __v_13: G = G::from_u64(132);
+    let __v_14: G = G::from_u64(150);
+    let __v_15: G = G::from_u64(153);
+    let __v_16: G = G::from_u64(120);
+    let __v_17: G = G::from_u64(146);
+    let __v_18: G = G::from_u64(225);
+    let __v_19: G = G::from_u64(121);
+    let __v_20: G = G::from_u64(131);
+    let __v_21: G = G::from_u64(209);
+    let __v_22: G = G::from_u64(75);
+    let __v_23: G = G::from_u64(229);
+    let __v_24: G = G::from_u64(39);
+    let __v_25: G = G::from_u64(10);
+    let __v_26: G = G::from_u64(113);
+    let __v_27: G = G::from_u64(101);
+    let __v_28: G = G::from_u64(112);
+    let __v_29: G = G::from_u64(179);
+    let __v_30: G = G::from_u64(87);
+    let __v_31: G = G::from_u64(25);
+    let __v_32: G = { let __values: [G; 32] = [__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]; 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_344] = [__v_32];
+    record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_345: usize = 0;
+const IN_345: usize = 0;
+const OUT_345: usize = 1;
+fn aiur_fn_345(
+  inp: [G; IN_345],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_345], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = G::from_u64(57);
+    let __v_1: G = G::from_u64(138);
+    let __v_2: G = G::from_u64(119);
+    let __v_3: G = G::from_u64(6);
+    let __v_4: G = G::from_u64(207);
+    let __v_5: G = G::from_u64(19);
+    let __v_6: G = G::from_u64(242);
+    let __v_7: G = G::from_u64(35);
+    let __v_8: G = G::from_u64(153);
+    let __v_9: G = G::from_u64(45);
+    let __v_10: G = G::from_u64(23);
+    let __v_11: G = G::from_u64(61);
+    let __v_12: G = G::from_u64(206);
+    let __v_13: G = G::from_u64(7);
+    let __v_14: G = G::from_u64(148);
+    let __v_15: G = G::from_u64(104);
+    let __v_16: G = G::from_u64(87);
+    let __v_17: G = G::from_u64(36);
+    let __v_18: G = G::from_u64(15);
+    let __v_19: G = G::from_u64(73);
+    let __v_20: G = G::from_u64(175);
+    let __v_21: G = G::from_u64(204);
+    let __v_22: G = G::from_u64(116);
+    let __v_23: G = G::from_u64(55);
+    let __v_24: G = G::from_u64(35);
+    let __v_25: G = G::from_u64(232);
+    let __v_26: G = G::from_u64(57);
+    let __v_27: G = G::from_u64(248);
+    let __v_28: G = G::from_u64(243);
+    let __v_29: G = G::from_u64(242);
+    let __v_30: G = G::from_u64(182);
+    let __v_31: G = G::from_u64(49);
+    let __v_32: G = { let __values: [G; 32] = [__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]; 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_345] = [__v_32];
+    record.function_queries[345].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_346: usize = 4;
+const IN_346: usize = 4;
+const OUT_346: usize = 2;
+fn aiur_fn_346(
+  inp: [G; IN_346],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_346], 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 __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_6, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-    let __v_7: G = __r_arr[0];
-    let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_5, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-    let __v_8: G = __r_arr[0];
-    let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].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 __v_17: G = __loaded[8];
-    let __v_18: G = __loaded[9];
-    let __v_19: G = __loaded[10];
-    match __v_9.as_canonical_u64() {
-      7u64 => {
-        let __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_1, __v_3, __v_10, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[441].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_441] = unsafe { *(result.output.as_ptr() as *const [G; OUT_441]) }; __ret } else { aiur_fn_441(__args, record, io_buffer, __cu)? } };
-        let __v_20: G = __r_arr[0];
-        let __v_21: G = __r_arr[1];
-        match __v_20.as_canonical_u64() {
-          1u64 => {
-            let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_21, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } };
-            let __v_22: G = __r_arr[0];
-            let __ret: [G; OUT_432] = [__v_22];
-            record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          0u64 => {
-            let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[427].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_427] = unsafe { *(result.output.as_ptr() as *const [G; OUT_427]) }; __ret } else { aiur_fn_427(__args, record, io_buffer, __cu)? } };
-            let __v_22: G = __r_arr[0];
-            let __ret: [G; OUT_432] = [__v_22];
-            record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_20.as_canonical_u64()));
-          },
-        }
-      },
-      4u64 => {
-        let __r_arr: [G; OUT_449] = { let __args: [G; IN_449] = [__v_12, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[449].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_449] = unsafe { *(result.output.as_ptr() as *const [G; OUT_449]) }; __ret } else { aiur_fn_449(__args, record, io_buffer, __cu)? } };
-        let __v_20: G = __r_arr[0];
-        let __v_21: G = __r_arr[1];
-        match __v_20.as_canonical_u64() {
-          1u64 => {
-            let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_21, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } };
-            let __v_22: G = __r_arr[0];
-            let __ret: [G; OUT_432] = [__v_22];
-            record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          0u64 => {
-            let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[427].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_427] = unsafe { *(result.output.as_ptr() as *const [G; OUT_427]) }; __ret } else { aiur_fn_427(__args, record, io_buffer, __cu)? } };
-            let __v_22: G = __r_arr[0];
-            let __ret: [G; OUT_432] = [__v_22];
-            record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_20.as_canonical_u64()));
-          },
-        }
+    let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } else { aiur_fn_343(__args, record, io_buffer, __cu)? } };
+    let __v_4: G = __r_arr[0];
+    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_5: G = __r_arr[0];
+    match __v_5.as_canonical_u64() {
+      0u64 => {
+        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 = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_9]; 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_346] = [__v_6, __v_10];
+        record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } else { aiur_fn_340(__args, record, io_buffer, __cu)? } };
-        let __v_20: G = __r_arr[0];
-        let __mc_out___mc_0: [G; 2] = '__mc_0: { match __v_20.as_canonical_u64() {
-  1u64 => {
-    let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_7, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[346].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_346] = unsafe { *(result.output.as_ptr() as *const [G; OUT_346]) }; __ret } else { aiur_fn_346(__args, record, io_buffer, __cu)? } };
-    let __v_21: G = __r_arr[0];
-    let __v_22: G = __r_arr[1];
-    break '__mc_0 [__v_21, __v_22];
-  },
-  2u64 => {
-    let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_7, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[374].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_374] = unsafe { *(result.output.as_ptr() as *const [G; OUT_374]) }; __ret } else { aiur_fn_374(__args, record, io_buffer, __cu)? } };
-    let __v_21: G = __r_arr[0];
-    let __v_22: G = __r_arr[1];
-    break '__mc_0 [__v_21, __v_22];
-  },
-  3u64 => {
-    let __r_arr: [G; OUT_356] = { let __args: [G; IN_356] = [__v_7, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[356].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_356] = unsafe { *(result.output.as_ptr() as *const [G; OUT_356]) }; __ret } else { aiur_fn_356(__args, record, io_buffer, __cu)? } };
-    let __v_21: G = __r_arr[0];
-    let __v_22: G = __r_arr[1];
-    break '__mc_0 [__v_21, __v_22];
-  },
-  4u64 => {
-    let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_7, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[358].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_358] = unsafe { *(result.output.as_ptr() as *const [G; OUT_358]) }; __ret } else { aiur_fn_358(__args, record, io_buffer, __cu)? } };
-    let __v_21: G = __r_arr[0];
-    let __v_22: G = __r_arr[1];
-    break '__mc_0 [__v_21, __v_22];
-  },
-  5u64 => {
-    let __r_arr: [G; OUT_365] = { let __args: [G; IN_365] = [__v_7, __v_0, __v_1, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[365].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_365] = unsafe { *(result.output.as_ptr() as *const [G; OUT_365]) }; __ret } else { aiur_fn_365(__args, record, io_buffer, __cu)? } };
-    let __v_21: G = __r_arr[0];
-    let __v_22: G = __r_arr[1];
-    break '__mc_0 [__v_21, __v_22];
-  },
-  _ => {
-    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 __v_24: G = G::from_u64(0);
-    let __v_25: G = { let __values: [G; 4] = [__v_22, __v_23, __v_24, __v_24]; 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 } };
-    break '__mc_0 [__v_21, __v_25];
-  },
-}
- };
-        let __v_21: G = __mc_out___mc_0[0];
-        let __v_22: G = __mc_out___mc_0[1];
-        match __v_21.as_canonical_u64() {
-          1u64 => {
-            let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_22, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } };
-            let __v_23: G = __r_arr[0];
-            let __ret: [G; OUT_432] = [__v_23];
-            record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          2u64 => {
-            let __ret: [G; OUT_432] = [__v_22];
-            record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
+        match __v_1.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_397] = { let __args: [G; IN_397] = [__v_0, __v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[397].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_397] = unsafe { *(result.output.as_ptr() as *const [G; OUT_397]) }; __ret } else { aiur_fn_397(__args, record, io_buffer, __cu)? } };
-            let __v_23: G = __r_arr[0];
-            let __v_24: G = __r_arr[1];
-            match __v_23.as_canonical_u64() {
-              1u64 => {
-                let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_24, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } };
-                let __v_25: G = __r_arr[0];
-                let __ret: [G; OUT_432] = [__v_25];
-                record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              0u64 => {
-                match __v_9.as_canonical_u64() {
-                  1u64 => {
-                    let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_12, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } };
-                    let __v_25: G = __r_arr[0];
-                    let __r_arr: [G; OUT_430] = { let __args: [G; IN_430] = [__v_25, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[430].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_430] = unsafe { *(result.output.as_ptr() as *const [G; OUT_430]) }; __ret } else { aiur_fn_430(__args, record, io_buffer, __cu)? } };
-                    let __v_26: G = __r_arr[0];
-                    let __ret: [G; OUT_432] = [__v_26];
-                    record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
-                  2u64 => {
-                    let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[427].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_427] = unsafe { *(result.output.as_ptr() as *const [G; OUT_427]) }; __ret } else { aiur_fn_427(__args, record, io_buffer, __cu)? } };
-                    let __v_25: G = __r_arr[0];
-                    let __ret: [G; OUT_432] = [__v_25];
-                    record.function_queries[432].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_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_6: G = __loaded[0];
+            let __v_7: G = __loaded[1];
+            let __v_8: G = __loaded[2];
+            let __v_9: G = __loaded[3];
+            match __v_6.as_canonical_u64() {
+              2u64 => {
+                let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[344].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_344] = unsafe { *(result.output.as_ptr() as *const [G; OUT_344]) }; __ret } else { aiur_fn_344(__args, record, io_buffer, __cu)? } };
+                let __v_10: G = __r_arr[0];
+                let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_11: G = __r_arr[0];
+                match __v_11.as_canonical_u64() {
+                  0u64 => {
+                    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 = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; 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_346] = [__v_12, __v_16];
+                    record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
-                    let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[427].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_427] = unsafe { *(result.output.as_ptr() as *const [G; OUT_427]) }; __ret } else { aiur_fn_427(__args, record, io_buffer, __cu)? } };
-                    let __v_25: G = __r_arr[0];
-                    let __ret: [G; OUT_432] = [__v_25];
-                    record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
+                    let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } else { aiur_fn_711(__args, record, io_buffer, __cu)? } };
+                    let __v_12: G = __r_arr[0];
+                    let __v_13: G = G::from_u64(5);
+                    let __v_14: G = { let __a_val = __v_12.as_canonical_u64(); let __b_val = __v_13.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_14.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 = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; 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_346] = [__v_15, __v_19];
+                        record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        return Ok(__ret);
+                      },
+                      _ => {
+                        let __v_15: G = G::from_u64(0);
+                        let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } };
+                        let __v_16: G = __r_arr[0];
+                        let __v_17: G = G::from_u64(1);
+                        let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_3, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } };
+                        let __v_18: G = __r_arr[0];
+                        let __v_19: G = G::from_u64(2);
+                        let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_3, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } };
+                        let __v_20: G = __r_arr[0];
+                        let __v_21: G = G::from_u64(3);
+                        let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_3, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } };
+                        let __v_22: G = __r_arr[0];
+                        let __v_23: G = G::from_u64(4);
+                        let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_3, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } };
+                        let __v_24: 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_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: 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() {
+                          4u64 => {
+                            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_20.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).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_29: G = __loaded[0];
+                            let __v_30: G = __loaded[1];
+                            let __v_31: G = __loaded[2];
+                            let __v_32: G = __loaded[3];
+                            match __v_29.as_canonical_u64() {
+                              4u64 => {
+                                let __v_33: G = G::from_u64(8);
+                                let __v_34: G = { let __values: [G; 4] = [__v_33, __v_0, __v_1, __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_35: G = G::from_u64(4);
+                                let __v_36: G = G::from_u64(0);
+                                let __v_37: G = { let __values: [G; 4] = [__v_35, __v_30, __v_34, __v_36]; 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 __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; 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: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+                                let __v_38: G = __loaded[0];
+                                let __v_39: G = __loaded[1];
+                                let __v_40: G = __loaded[2];
+                                let __v_41: G = __loaded[3];
+                                match __v_38.as_canonical_u64() {
+                                  4u64 => {
+                                    let __v_42: G = G::from_u64(8);
+                                    let __v_43: G = { let __values: [G; 4] = [__v_42, __v_0, __v_1, __v_40]; 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_44: G = G::from_u64(4);
+                                    let __v_45: G = G::from_u64(0);
+                                    let __v_46: G = { let __values: [G; 4] = [__v_44, __v_39, __v_43, __v_45]; 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_47: G = G::from_u64(2);
+                                    let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[345].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_345] = unsafe { *(result.output.as_ptr() as *const [G; OUT_345]) }; __ret } else { aiur_fn_345(__args, record, io_buffer, __cu)? } };
+                                    let __v_48: G = __r_arr[0];
+                                    let __v_49: G = G::from_u64(1);
+                                    let __v_50: G = G::from_u64(1);
+                                    let __v_51: G = { let __values: [G; 3] = [__v_49, __v_50, __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 = G::from_u64(0);
+                                    let __v_53: G = { let __values: [G; 4] = [__v_47, __v_48, __v_51, __v_52]; 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_54: G = G::from_u64(4);
+                                    let __v_55: G = G::from_u64(0);
+                                    let __v_56: G = { let __values: [G; 4] = [__v_54, __v_26, __v_53, __v_55]; 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_57: G = G::from_u64(2);
+                                    let __v_58: G = G::from_u64(0);
+                                    let __v_59: G = { let __values: [G; 4] = [__v_57, __v_7, __v_8, __v_58]; 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_60: G = G::from_u64(3);
+                                    let __v_61: G = G::from_u64(0);
+                                    let __v_62: G = { let __values: [G; 4] = [__v_60, __v_59, __v_16, __v_61]; 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_63: G = G::from_u64(3);
+                                    let __v_64: G = G::from_u64(0);
+                                    let __v_65: G = { let __values: [G; 4] = [__v_63, __v_62, __v_56, __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 __v_66: G = G::from_u64(3);
+                                    let __v_67: G = G::from_u64(0);
+                                    let __v_68: G = { let __values: [G; 4] = [__v_66, __v_65, __v_37, __v_67]; 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_69: G = G::from_u64(3);
+                                    let __v_70: G = G::from_u64(0);
+                                    let __v_71: G = { let __values: [G; 4] = [__v_69, __v_68, __v_46, __v_70]; 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_72: G = G::from_u64(3);
+                                    let __v_73: G = G::from_u64(0);
+                                    let __v_74: G = { let __values: [G; 4] = [__v_72, __v_71, __v_24, __v_73]; 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_75: G = G::from_u64(5);
+                                    let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_3, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } };
+                                    let __v_76: G = __r_arr[0];
+                                    let __v_77: G = G::from_u64(1);
+                                    let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_74, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } };
+                                    let __v_78: G = __r_arr[0];
+                                    let __ret: [G; OUT_346] = [__v_77, __v_78];
+                                    record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                    return Ok(__ret);
+                                  },
+                                  _ => {
+                                    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; 4] = [__v_43, __v_44, __v_45, __v_45]; 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_346] = [__v_42, __v_46];
+                                    record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                    return Ok(__ret);
+                                  },
+                                }
+                              },
+                              _ => {
+                                let __v_33: G = G::from_u64(0);
+                                let __v_34: G = G::from_u64(0);
+                                let __v_35: G = G::from_u64(0);
+                                let __v_36: G = G::from_u64(0);
+                                let __v_37: G = { let __values: [G; 4] = [__v_34, __v_35, __v_36, __v_36]; 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_346] = [__v_33, __v_37];
+                                record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                return Ok(__ret);
+                              },
+                            }
+                          },
+                          _ => {
+                            let __v_29: G = G::from_u64(0);
+                            let __v_30: G = G::from_u64(0);
+                            let __v_31: G = G::from_u64(0);
+                            let __v_32: G = G::from_u64(0);
+                            let __v_33: G = { let __values: [G; 4] = [__v_30, __v_31, __v_32, __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 __ret: [G; OUT_346] = [__v_29, __v_33];
+                            record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            return Ok(__ret);
+                          },
+                        }
+                      },
+                    }
                   },
                 }
               },
               _ => {
-                return Err(ExecError::MatchNoCase(__v_23.as_canonical_u64()));
+                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 = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; 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_346] = [__v_10, __v_14];
+                record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
               },
             }
           },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_21.as_canonical_u64()));
+            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 = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_9]; 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_346] = [__v_6, __v_10];
+            record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
           },
         }
       },
@@ -39196,1296 +31062,865 @@ fn aiur_fn_432(
   })
 }
 
-const INPUT_SIZE_433: usize = 4;
-const IN_433: usize = 4;
-const OUT_433: usize = 1;
-fn aiur_fn_433(
-  inp: [G; IN_433],
+const INPUT_SIZE_347: usize = 1;
+const IN_347: usize = 1;
+const OUT_347: usize = 1;
+fn aiur_fn_347(
+  inp: [G; IN_347],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_433], ExecError> {
+) -> Result<[G; OUT_347], 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; 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_4: G = __loaded[0];
-    let __v_5: G = __loaded[1];
-    let __v_6: G = __loaded[2];
-    let __v_7: G = __loaded[3];
-    match __v_4.as_canonical_u64() {
-      1u64 => {
-        let __ret: [G; OUT_433] = [__v_0];
-        record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      7u64 => {
-        let __ret: [G; OUT_433] = [__v_0];
-        record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      4u64 => {
-        let __ret: [G; OUT_433] = [__v_0];
-        record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      5u64 => {
-        let __ret: [G; OUT_433] = [__v_0];
-        record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __ret: [G; OUT_433] = [__v_0];
-        record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    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() {
+      2u64 => {
+        let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[258].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_258] = unsafe { *(result.output.as_ptr() as *const [G; OUT_258]) }; __ret } else { aiur_fn_258(__args, record, io_buffer, __cu)? } };
+        let __v_5: G = __r_arr[0];
+        let __ret: [G; OUT_347] = [__v_5];
+        record.function_queries[347].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } };
-        let __v_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_1, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[412].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_412] = unsafe { *(result.output.as_ptr() as *const [G; OUT_412]) }; __ret } else { aiur_fn_412(__args, record, io_buffer, __cu)? } };
-        let __v_9: G = __r_arr[0];
-        let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_0, __v_9, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[434].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_434] = unsafe { *(result.output.as_ptr() as *const [G; OUT_434]) }; __ret } else { aiur_fn_434(__args, record, io_buffer, __cu)? } };
-        let __v_10: G = __r_arr[0];
-        let __ret: [G; OUT_433] = [__v_10];
-        record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __v_5: G = G::from_u64(0);
+        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 = { let __values: [G; 3] = [__v_8, __v_9, __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 = G::from_u64(0);
+        let __v_12: G = { let __values: [G; 4] = [__v_7, __v_10, __v_11, __v_11]; 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_13: G = G::from_u64(0);
+        let __v_14: G = G::from_u64(0);
+        let __v_15: G = { let __values: [G; 12] = [__v_5, __v_6, __v_12, __v_13, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_347] = [__v_15];
+        record.function_queries[347].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_434: usize = 4;
-const IN_434: usize = 4;
-const OUT_434: usize = 1;
-fn aiur_fn_434(
-  inp: [G; IN_434],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_434], 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_189] = { let __args: [G; IN_189] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[189].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_189] = unsafe { *(result.output.as_ptr() as *const [G; OUT_189]) }; __ret } else { aiur_fn_189(__args, record, io_buffer, __cu)? } };
-    let __v_4: G = __r_arr[0];
-    let __v_5: G = __r_arr[1];
-    let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_4, __v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } else { aiur_fn_435(__args, record, io_buffer, __cu)? } };
-    let __v_6: G = __r_arr[0];
-    let __ret: [G; OUT_434] = [__v_6];
-    record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_435: usize = 5;
-const IN_435: usize = 5;
-const OUT_435: usize = 1;
-fn aiur_fn_435(
-  inp: [G; IN_435],
+const INPUT_SIZE_348: usize = 2;
+const IN_348: usize = 2;
+const OUT_348: usize = 1;
+fn aiur_fn_348(
+  inp: [G; IN_348],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_435], ExecError> {
+) -> Result<[G; OUT_348], 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 __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_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() {
-      3u64 => {
-        let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[189].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_189] = unsafe { *(result.output.as_ptr() as *const [G; OUT_189]) }; __ret } else { aiur_fn_189(__args, record, io_buffer, __cu)? } };
-        let __v_9: G = __r_arr[0];
-        let __v_10: G = __r_arr[1];
-        let __r_arr: [G; OUT_773] = { let __args: [G; IN_773] = [__v_10, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[773].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_773] = unsafe { *(result.output.as_ptr() as *const [G; OUT_773]) }; __ret } else { aiur_fn_773(__args, record, io_buffer, __cu)? } };
-        let __v_11: G = __r_arr[0];
-        let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_9, __v_11, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } else { aiur_fn_435(__args, record, io_buffer, __cu)? } };
-        let __v_12: G = __r_arr[0];
-        let __ret: [G; OUT_435] = [__v_12];
-        record.function_queries[435].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      4u64 => {
-        let __r_arr: [G; OUT_436] = { let __args: [G; IN_436] = [__v_1, __v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[436].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_436] = unsafe { *(result.output.as_ptr() as *const [G; OUT_436]) }; __ret } else { aiur_fn_436(__args, record, io_buffer, __cu)? } };
-        let __v_9: G = __r_arr[0];
-        let __ret: [G; OUT_435] = [__v_9];
-        record.function_queries[435].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      2u64 => {
-        let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_6, __v_7, __v_0, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } else { aiur_fn_438(__args, record, io_buffer, __cu)? } };
-        let __v_9: G = __r_arr[0];
-        let __ret: [G; OUT_435] = [__v_9];
-        record.function_queries[435].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      6u64 => {
-        let __v_9: G = G::from_u64(0);
-        let __r_arr: [G; OUT_419] = { let __args: [G; IN_419] = [__v_8, __v_7, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[419].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_419] = unsafe { *(result.output.as_ptr() as *const [G; OUT_419]) }; __ret } else { aiur_fn_419(__args, record, io_buffer, __cu)? } };
-        let __v_10: G = __r_arr[0];
-        let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_10, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } else { aiur_fn_435(__args, record, io_buffer, __cu)? } };
-        let __v_11: G = __r_arr[0];
-        let __ret: [G; OUT_435] = [__v_11];
-        record.function_queries[435].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_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 __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_348] = [__v_7];
+        record.function_queries[348].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      8u64 => {
-        let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_6, __v_7, __v_8, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[437].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_437] = unsafe { *(result.output.as_ptr() as *const [G; OUT_437]) }; __ret } else { aiur_fn_437(__args, record, io_buffer, __cu)? } };
-        let __v_9: G = __r_arr[0];
-        let __ret: [G; OUT_435] = [__v_9];
-        record.function_queries[435].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+      0u64 => {
+        let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = unsafe { *(result.output.as_ptr() as *const [G; OUT_377]) }; __ret } else { aiur_fn_377(__args, record, io_buffer, __cu)? } };
+        let __v_5: G = __r_arr[0];
+        let __v_6: G = G::from_u64(0);
+        let __r_arr: [G; OUT_348] = { let __args: [G; IN_348] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[348].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_348] = unsafe { *(result.output.as_ptr() as *const [G; OUT_348]) }; __ret } else { aiur_fn_348(__args, record, io_buffer, __cu)? } };
+        let __v_7: G = __r_arr[0];
+        let __v_8: G = { let __values: [G; 3] = [__v_6, __v_5, __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_348] = [__v_8];
+        record.function_queries[348].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[427].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_427] = unsafe { *(result.output.as_ptr() as *const [G; OUT_427]) }; __ret } else { aiur_fn_427(__args, record, io_buffer, __cu)? } };
-        let __v_9: G = __r_arr[0];
-        let __ret: [G; OUT_435] = [__v_9];
-        record.function_queries[435].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_436: usize = 5;
-const IN_436: usize = 5;
-const OUT_436: usize = 1;
-fn aiur_fn_436(
-  inp: [G; IN_436],
+const INPUT_SIZE_349: usize = 3;
+const IN_349: usize = 3;
+const OUT_349: usize = 2;
+fn aiur_fn_349(
+  inp: [G; IN_349],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_436], ExecError> {
+) -> Result<[G; OUT_349], 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(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 __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_1, __v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[428].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_428] = unsafe { *(result.output.as_ptr() as *const [G; OUT_428]) }; __ret } else { aiur_fn_428(__args, record, io_buffer, __cu)? } };
-    let __v_8: G = __r_arr[0];
-    let __v_9: G = __r_arr[1];
-    let __v_10: G = __r_arr[2];
-    let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { 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_11: G = __r_arr[0];
-    match __v_11.as_canonical_u64() {
-      0u64 => {
-        let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_1, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[427].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_427] = unsafe { *(result.output.as_ptr() as *const [G; OUT_427]) }; __ret } else { aiur_fn_427(__args, record, io_buffer, __cu)? } };
-        let __v_12: G = __r_arr[0];
-        let __ret: [G; OUT_436] = [__v_12];
-        record.function_queries[436].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      1u64 => {
-        let __v_12: G = G::from_u64(0);
-        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_9, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-        let __v_13: G = __r_arr[0];
-        let __v_14: G = G::from_u64(0);
-        let __r_arr: [G; OUT_419] = { let __args: [G; IN_419] = [__v_8, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[419].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_419] = unsafe { *(result.output.as_ptr() as *const [G; OUT_419]) }; __ret } else { aiur_fn_419(__args, record, io_buffer, __cu)? } };
-        let __v_15: G = __r_arr[0];
-        let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_15, __v_10, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } else { aiur_fn_435(__args, record, io_buffer, __cu)? } };
-        let __v_16: G = __r_arr[0];
-        let __ret: [G; OUT_436] = [__v_16];
-        record.function_queries[436].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        let __v_12: G = G::from_u64(0);
-        let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_8, __v_9, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[423].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_423] = unsafe { *(result.output.as_ptr() as *const [G; OUT_423]) }; __ret } else { aiur_fn_423(__args, record, io_buffer, __cu)? } };
-        let __v_13: G = __r_arr[0];
-        let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_13, __v_10, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } else { aiur_fn_435(__args, record, io_buffer, __cu)? } };
-        let __v_14: G = __r_arr[0];
-        let __ret: [G; OUT_436] = [__v_14];
-        record.function_queries[436].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-    }
+    let __r_arr: [G; OUT_348] = { let __args: [G; IN_348] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[348].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_348] = unsafe { *(result.output.as_ptr() as *const [G; OUT_348]) }; __ret } else { aiur_fn_348(__args, record, io_buffer, __cu)? } };
+    let __v_3: G = __r_arr[0];
+    let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_0, __v_3, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[236].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_236] = unsafe { *(result.output.as_ptr() as *const [G; OUT_236]) }; __ret } else { aiur_fn_236(__args, record, io_buffer, __cu)? } };
+    let __v_4: G = __r_arr[0];
+    let __v_5: G = __r_arr[1];
+    let __ret: [G; OUT_349] = [__v_4, __v_5];
+    record.function_queries[349].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_437: usize = 7;
-const IN_437: usize = 7;
-const OUT_437: usize = 1;
-fn aiur_fn_437(
-  inp: [G; IN_437],
+const INPUT_SIZE_350: usize = 2;
+const IN_350: usize = 2;
+const OUT_350: usize = 1;
+fn aiur_fn_350(
+  inp: [G; IN_350],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_437], ExecError> {
+) -> Result<[G; OUT_350], 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 __r_arr: [G; OUT_433] = { let __args: [G; IN_433] = [__v_2, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[433].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_433] = unsafe { *(result.output.as_ptr() as *const [G; OUT_433]) }; __ret } else { aiur_fn_433(__args, record, io_buffer, __cu)? } };
-    let __v_7: G = __r_arr[0];
-    let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_7, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = unsafe { *(result.output.as_ptr() as *const [G; OUT_396]) }; __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } };
-    let __v_8: G = __r_arr[0];
-    let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[189].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_189] = unsafe { *(result.output.as_ptr() as *const [G; OUT_189]) }; __ret } else { aiur_fn_189(__args, record, io_buffer, __cu)? } };
-    let __v_9: G = __r_arr[0];
-    let __v_10: G = __r_arr[1];
-    let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_0, __v_1, __v_9, __v_10, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[398].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_398] = unsafe { *(result.output.as_ptr() as *const [G; OUT_398]) }; __ret } else { aiur_fn_398(__args, record, io_buffer, __cu)? } };
-    let __v_11: G = __r_arr[0];
-    let __v_12: G = __r_arr[1];
-    match __v_11.as_canonical_u64() {
+    let __r_arr: [G; OUT_348] = { let __args: [G; IN_348] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[348].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_348] = unsafe { *(result.output.as_ptr() as *const [G; OUT_348]) }; __ret } else { aiur_fn_348(__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];
+    let __v_4: G = __loaded[1];
+    let __v_5: G = __loaded[2];
+    match __v_3.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_12, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } else { aiur_fn_435(__args, record, io_buffer, __cu)? } };
-        let __v_13: G = __r_arr[0];
-        let __ret: [G; OUT_437] = [__v_13];
-        record.function_queries[437].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_350] = [__v_2];
+        record.function_queries[350].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_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: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
-        let __v_13: G = __loaded[0];
-        let __v_14: G = __loaded[1];
-        let __v_15: G = __loaded[2];
-        let __v_16: G = __loaded[3];
-        match __v_13.as_canonical_u64() {
-          2u64 => {
-            let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_5, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-            let __v_17: G = __r_arr[0];
-            let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_17.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].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];
-            let __v_22: G = __loaded[4];
-            let __v_23: G = __loaded[5];
-            let __v_24: G = __loaded[6];
-            let __v_25: G = __loaded[7];
-            let __v_26: G = __loaded[8];
-            let __v_27: G = __loaded[9];
-            let __v_28: G = __loaded[10];
-            match __v_18.as_canonical_u64() {
-              6u64 => {
-                let __v_29: G = (__v_23 + __v_1);
-                let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_10, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[455].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_455] = unsafe { *(result.output.as_ptr() as *const [G; OUT_455]) }; __ret } else { aiur_fn_455(__args, record, io_buffer, __cu)? } };
-                let __v_30: G = __r_arr[0];
-                let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_30, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } else { aiur_fn_435(__args, record, io_buffer, __cu)? } };
-                let __v_31: G = __r_arr[0];
-                let __ret: [G; OUT_437] = [__v_31];
-                record.function_queries[437].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              _ => {
-                let __v_29: G = G::from_u64(8);
-                let __v_30: G = { let __values: [G; 4] = [__v_29, __v_0, __v_1, __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 __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_30, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[427].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_427] = unsafe { *(result.output.as_ptr() as *const [G; OUT_427]) }; __ret } else { aiur_fn_427(__args, record, io_buffer, __cu)? } };
-                let __v_31: G = __r_arr[0];
-                let __ret: [G; OUT_437] = [__v_31];
-                record.function_queries[437].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_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_6: G = __loaded[0];
+        let __v_7: G = __loaded[1];
+        let __v_8: G = __loaded[2];
+        match __v_6.as_canonical_u64() {
+          1u64 => {
+            let __ret: [G; OUT_350] = [__v_2];
+            record.function_queries[350].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
           },
-          _ => {
-            let __v_17: G = G::from_u64(8);
-            let __v_18: G = { let __values: [G; 4] = [__v_17, __v_0, __v_1, __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 __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_18, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[427].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_427] = unsafe { *(result.output.as_ptr() as *const [G; OUT_427]) }; __ret } else { aiur_fn_427(__args, record, io_buffer, __cu)? } };
-            let __v_19: G = __r_arr[0];
-            let __ret: [G; OUT_437] = [__v_19];
-            record.function_queries[437].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+          0u64 => {
+            let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[106].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_106] = unsafe { *(result.output.as_ptr() as *const [G; OUT_106]) }; __ret } else { aiur_fn_106(__args, record, io_buffer, __cu)? } };
+            let __v_9: G = __r_arr[0];
+            let __v_10: G = __r_arr[1];
+            let __r_arr: [G; OUT_348] = { let __args: [G; IN_348] = [__v_10, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[348].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_348] = unsafe { *(result.output.as_ptr() as *const [G; OUT_348]) }; __ret } else { aiur_fn_348(__args, record, io_buffer, __cu)? } };
+            let __v_11: G = __r_arr[0];
+            let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_9, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } };
+            let __v_12: G = __r_arr[0];
+            let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = unsafe { *(result.output.as_ptr() as *const [G; OUT_377]) }; __ret } else { aiur_fn_377(__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(0);
+            let __v_16: G = { let __values: [G; 3] = [__v_15, __v_12, __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_17: G = { let __values: [G; 3] = [__v_14, __v_13, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_350] = [__v_17];
+            record.function_queries[350].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64()));
+          },
         }
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64()));
+        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_438: usize = 7;
-const IN_438: usize = 7;
-const OUT_438: usize = 1;
-fn aiur_fn_438(
-  inp: [G; IN_438],
+const INPUT_SIZE_351: usize = 1;
+const IN_351: usize = 1;
+const OUT_351: usize = 1;
+fn aiur_fn_351(
+  inp: [G; IN_351],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_438], ExecError> {
+) -> Result<[G; OUT_351], 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 __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_6, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-    let __v_7: G = __r_arr[0];
-    let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_5, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-    let __v_8: G = __r_arr[0];
-    let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].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 __v_17: G = __loaded[8];
-    let __v_18: G = __loaded[9];
-    let __v_19: G = __loaded[10];
-    match __v_9.as_canonical_u64() {
-      7u64 => {
-        let __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_1, __v_3, __v_10, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[441].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_441] = unsafe { *(result.output.as_ptr() as *const [G; OUT_441]) }; __ret } else { aiur_fn_441(__args, record, io_buffer, __cu)? } };
-        let __v_20: G = __r_arr[0];
-        let __v_21: G = __r_arr[1];
-        match __v_20.as_canonical_u64() {
-          1u64 => {
-            let __r_arr: [G; OUT_433] = { let __args: [G; IN_433] = [__v_21, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[433].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_433] = unsafe { *(result.output.as_ptr() as *const [G; OUT_433]) }; __ret } else { aiur_fn_433(__args, record, io_buffer, __cu)? } };
-            let __v_22: G = __r_arr[0];
-            let __ret: [G; OUT_438] = [__v_22];
-            record.function_queries[438].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          0u64 => {
-            let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[427].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_427] = unsafe { *(result.output.as_ptr() as *const [G; OUT_427]) }; __ret } else { aiur_fn_427(__args, record, io_buffer, __cu)? } };
-            let __v_22: G = __r_arr[0];
-            let __ret: [G; OUT_438] = [__v_22];
-            record.function_queries[438].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_20.as_canonical_u64()));
-          },
-        }
-      },
-      4u64 => {
-        let __r_arr: [G; OUT_449] = { let __args: [G; IN_449] = [__v_12, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[449].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_449] = unsafe { *(result.output.as_ptr() as *const [G; OUT_449]) }; __ret } else { aiur_fn_449(__args, record, io_buffer, __cu)? } };
-        let __v_20: G = __r_arr[0];
-        let __v_21: G = __r_arr[1];
-        match __v_20.as_canonical_u64() {
-          1u64 => {
-            let __r_arr: [G; OUT_433] = { let __args: [G; IN_433] = [__v_21, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[433].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_433] = unsafe { *(result.output.as_ptr() as *const [G; OUT_433]) }; __ret } else { aiur_fn_433(__args, record, io_buffer, __cu)? } };
-            let __v_22: G = __r_arr[0];
-            let __ret: [G; OUT_438] = [__v_22];
-            record.function_queries[438].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          0u64 => {
-            let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[427].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_427] = unsafe { *(result.output.as_ptr() as *const [G; OUT_427]) }; __ret } else { aiur_fn_427(__args, record, io_buffer, __cu)? } };
-            let __v_22: G = __r_arr[0];
-            let __ret: [G; OUT_438] = [__v_22];
-            record.function_queries[438].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_20.as_canonical_u64()));
-          },
-        }
+    let __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[224].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_224] = unsafe { *(result.output.as_ptr() as *const [G; OUT_224]) }; __ret } else { aiur_fn_224(__args, record, io_buffer, __cu)? } };
+    let __v_1: G = __r_arr[0];
+    match __v_1.as_canonical_u64() {
+      1u64 => {
+        let __v_2: G = G::from_u64(1);
+        let __ret: [G; OUT_351] = [__v_2];
+        record.function_queries[351].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } else { aiur_fn_340(__args, record, io_buffer, __cu)? } };
-        let __v_20: G = __r_arr[0];
-        let __mc_out___mc_0: [G; 2] = '__mc_0: { match __v_20.as_canonical_u64() {
-  1u64 => {
-    let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_7, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[346].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_346] = unsafe { *(result.output.as_ptr() as *const [G; OUT_346]) }; __ret } else { aiur_fn_346(__args, record, io_buffer, __cu)? } };
-    let __v_21: G = __r_arr[0];
-    let __v_22: G = __r_arr[1];
-    break '__mc_0 [__v_21, __v_22];
-  },
-  2u64 => {
-    let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_7, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[374].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_374] = unsafe { *(result.output.as_ptr() as *const [G; OUT_374]) }; __ret } else { aiur_fn_374(__args, record, io_buffer, __cu)? } };
-    let __v_21: G = __r_arr[0];
-    let __v_22: G = __r_arr[1];
-    break '__mc_0 [__v_21, __v_22];
-  },
-  3u64 => {
-    let __r_arr: [G; OUT_356] = { let __args: [G; IN_356] = [__v_7, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[356].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_356] = unsafe { *(result.output.as_ptr() as *const [G; OUT_356]) }; __ret } else { aiur_fn_356(__args, record, io_buffer, __cu)? } };
-    let __v_21: G = __r_arr[0];
-    let __v_22: G = __r_arr[1];
-    break '__mc_0 [__v_21, __v_22];
-  },
-  4u64 => {
-    let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_7, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[358].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_358] = unsafe { *(result.output.as_ptr() as *const [G; OUT_358]) }; __ret } else { aiur_fn_358(__args, record, io_buffer, __cu)? } };
-    let __v_21: G = __r_arr[0];
-    let __v_22: G = __r_arr[1];
-    break '__mc_0 [__v_21, __v_22];
-  },
-  5u64 => {
-    let __r_arr: [G; OUT_365] = { let __args: [G; IN_365] = [__v_7, __v_0, __v_1, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[365].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_365] = unsafe { *(result.output.as_ptr() as *const [G; OUT_365]) }; __ret } else { aiur_fn_365(__args, record, io_buffer, __cu)? } };
-    let __v_21: G = __r_arr[0];
-    let __v_22: G = __r_arr[1];
-    break '__mc_0 [__v_21, __v_22];
-  },
-  _ => {
-    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 __v_24: G = G::from_u64(0);
-    let __v_25: G = { let __values: [G; 4] = [__v_22, __v_23, __v_24, __v_24]; 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 } };
-    break '__mc_0 [__v_21, __v_25];
-  },
-}
- };
-        let __v_21: G = __mc_out___mc_0[0];
-        let __v_22: G = __mc_out___mc_0[1];
-        match __v_21.as_canonical_u64() {
+        let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { 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 __v_2: G = __r_arr[0];
+        match __v_2.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_433] = { let __args: [G; IN_433] = [__v_22, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[433].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_433] = unsafe { *(result.output.as_ptr() as *const [G; OUT_433]) }; __ret } else { aiur_fn_433(__args, record, io_buffer, __cu)? } };
-            let __v_23: G = __r_arr[0];
-            let __ret: [G; OUT_438] = [__v_23];
-            record.function_queries[438].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          2u64 => {
-            let __ret: [G; OUT_438] = [__v_22];
-            record.function_queries[438].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __v_3: G = G::from_u64(2);
+            let __ret: [G; OUT_351] = [__v_3];
+            record.function_queries[351].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
-          0u64 => {
-            let __r_arr: [G; OUT_397] = { let __args: [G; IN_397] = [__v_0, __v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[397].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_397] = unsafe { *(result.output.as_ptr() as *const [G; OUT_397]) }; __ret } else { aiur_fn_397(__args, record, io_buffer, __cu)? } };
-            let __v_23: G = __r_arr[0];
-            let __v_24: G = __r_arr[1];
-            match __v_23.as_canonical_u64() {
+          _ => {
+            let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[180].get_mut(&__args[..]) { 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_3: G = __r_arr[0];
+            match __v_3.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_433] = { let __args: [G; IN_433] = [__v_24, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[433].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_433] = unsafe { *(result.output.as_ptr() as *const [G; OUT_433]) }; __ret } else { aiur_fn_433(__args, record, io_buffer, __cu)? } };
-                let __v_25: G = __r_arr[0];
-                let __ret: [G; OUT_438] = [__v_25];
-                record.function_queries[438].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              0u64 => {
-                let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[427].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_427] = unsafe { *(result.output.as_ptr() as *const [G; OUT_427]) }; __ret } else { aiur_fn_427(__args, record, io_buffer, __cu)? } };
-                let __v_25: G = __r_arr[0];
-                let __ret: [G; OUT_438] = [__v_25];
-                record.function_queries[438].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __v_4: G = G::from_u64(3);
+                let __ret: [G; OUT_351] = [__v_4];
+                record.function_queries[351].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                return Err(ExecError::MatchNoCase(__v_23.as_canonical_u64()));
+                let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[166].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_166] = unsafe { *(result.output.as_ptr() as *const [G; OUT_166]) }; __ret } else { aiur_fn_166(__args, record, io_buffer, __cu)? } };
+                let __v_4: G = __r_arr[0];
+                match __v_4.as_canonical_u64() {
+                  1u64 => {
+                    let __v_5: G = G::from_u64(4);
+                    let __ret: [G; OUT_351] = [__v_5];
+                    record.function_queries[351].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
+                  },
+                  _ => {
+                    let __r_arr: [G; OUT_462] = { let __args: [G; IN_462] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[462].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_462] = unsafe { *(result.output.as_ptr() as *const [G; OUT_462]) }; __ret } else { aiur_fn_462(__args, record, io_buffer, __cu)? } };
+                    let __v_5: G = __r_arr[0];
+                    match __v_5.as_canonical_u64() {
+                      1u64 => {
+                        let __v_6: G = G::from_u64(5);
+                        let __ret: [G; OUT_351] = [__v_6];
+                        record.function_queries[351].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        return Ok(__ret);
+                      },
+                      _ => {
+                        let __v_6: G = G::from_u64(0);
+                        let __ret: [G; OUT_351] = [__v_6];
+                        record.function_queries[351].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        return Ok(__ret);
+                      },
+                    }
+                  },
+                }
               },
             }
           },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_21.as_canonical_u64()));
-          },
         }
       },
     }
   })
 }
 
-const INPUT_SIZE_439: usize = 4;
-const IN_439: usize = 4;
-const OUT_439: usize = 1;
-fn aiur_fn_439(
-  inp: [G; IN_439],
+const INPUT_SIZE_352: usize = 4;
+const IN_352: usize = 4;
+const OUT_352: usize = 2;
+fn aiur_fn_352(
+  inp: [G; IN_352],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_439], ExecError> {
+) -> Result<[G; OUT_352], 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; 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_4: G = __loaded[0];
-    let __v_5: G = __loaded[1];
-    let __v_6: G = __loaded[2];
-    let __v_7: G = __loaded[3];
+    let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[351].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_351] = unsafe { *(result.output.as_ptr() as *const [G; OUT_351]) }; __ret } else { aiur_fn_351(__args, record, io_buffer, __cu)? } };
+    let __v_4: G = __r_arr[0];
     match __v_4.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_439] = [__v_0];
-        record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_349] = { let __args: [G; IN_349] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[349].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_349] = unsafe { *(result.output.as_ptr() as *const [G; OUT_349]) }; __ret } else { aiur_fn_349(__args, record, io_buffer, __cu)? } };
+        let __v_5: G = __r_arr[0];
+        let __v_6: G = __r_arr[1];
+        let __ret: [G; OUT_352] = [__v_5, __v_6];
+        record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      7u64 => {
-        let __ret: [G; OUT_439] = [__v_0];
-        record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+      2u64 => {
+        let __r_arr: [G; OUT_348] = { let __args: [G; IN_348] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[348].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_348] = unsafe { *(result.output.as_ptr() as *const [G; OUT_348]) }; __ret } else { aiur_fn_348(__args, record, io_buffer, __cu)? } };
+        let __v_5: G = __r_arr[0];
+        let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_0, __v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { 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_6: G = __r_arr[0];
+        let __v_7: G = __r_arr[1];
+        let __ret: [G; OUT_352] = [__v_6, __v_7];
+        record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      4u64 => {
-        let __ret: [G; OUT_439] = [__v_0];
-        record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+      3u64 => {
+        let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[186].get_mut(&__args[..]) { 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_5: G = __r_arr[0];
+        let __v_6: G = __r_arr[1];
+        let __ret: [G; OUT_352] = [__v_5, __v_6];
+        record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      5u64 => {
-        let __ret: [G; OUT_439] = [__v_0];
-        record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+      4u64 => {
+        let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[169].get_mut(&__args[..]) { 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_5: G = __r_arr[0];
+        let __v_6: G = __r_arr[1];
+        let __ret: [G; OUT_352] = [__v_5, __v_6];
+        record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __ret: [G; OUT_439] = [__v_0];
-        record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+      5u64 => {
+        let __r_arr: [G; OUT_468] = { let __args: [G; IN_468] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[468].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_468] = unsafe { *(result.output.as_ptr() as *const [G; OUT_468]) }; __ret } else { aiur_fn_468(__args, record, io_buffer, __cu)? } };
+        let __v_5: G = __r_arr[0];
+        let __v_6: G = __r_arr[1];
+        let __ret: [G; OUT_352] = [__v_5, __v_6];
+        record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } };
-        let __v_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_1, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[412].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_412] = unsafe { *(result.output.as_ptr() as *const [G; OUT_412]) }; __ret } else { aiur_fn_412(__args, record, io_buffer, __cu)? } };
-        let __v_9: G = __r_arr[0];
-        let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_0, __v_9, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = unsafe { *(result.output.as_ptr() as *const [G; OUT_440]) }; __ret } else { aiur_fn_440(__args, record, io_buffer, __cu)? } };
-        let __v_10: G = __r_arr[0];
-        let __ret: [G; OUT_439] = [__v_10];
-        record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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; 4] = [__v_6, __v_7, __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_352] = [__v_5, __v_9];
+        record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_440: usize = 4;
-const IN_440: usize = 4;
-const OUT_440: usize = 1;
-fn aiur_fn_440(
-  inp: [G; IN_440],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_440], 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_189] = { let __args: [G; IN_189] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[189].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_189] = unsafe { *(result.output.as_ptr() as *const [G; OUT_189]) }; __ret } else { aiur_fn_189(__args, record, io_buffer, __cu)? } };
-    let __v_4: G = __r_arr[0];
-    let __v_5: G = __r_arr[1];
-    let __r_arr: [G; OUT_430] = { let __args: [G; IN_430] = [__v_4, __v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[430].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_430] = unsafe { *(result.output.as_ptr() as *const [G; OUT_430]) }; __ret } else { aiur_fn_430(__args, record, io_buffer, __cu)? } };
-    let __v_6: G = __r_arr[0];
-    let __ret: [G; OUT_440] = [__v_6];
-    record.function_queries[440].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_441: usize = 12;
-const IN_441: usize = 12;
-const OUT_441: usize = 2;
-fn aiur_fn_441(
-  inp: [G; IN_441],
+const INPUT_SIZE_353: usize = 3;
+const IN_353: usize = 3;
+const OUT_353: usize = 2;
+fn aiur_fn_353(
+  inp: [G; IN_353],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_441], ExecError> {
+) -> Result<[G; OUT_353], 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 = (__v_6 + __v_4);
-    let __v_13: G = (__v_5 + __v_12);
-    let __v_14: G = (__v_3 + __v_13);
-    let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { 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_15: G = __r_arr[0];
-    let __v_16: G = { let __a_val = __v_14.as_canonical_u64(); let __b_val = __v_15.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_16.as_canonical_u64() {
-      0u64 => {
-        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 = { let __values: [G; 4] = [__v_18, __v_19, __v_20, __v_20]; 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_441] = [__v_17, __v_21];
-        record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    match __v_0.as_canonical_u64() {
+      2u64 => {
+        let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[354].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_354] = unsafe { *(result.output.as_ptr() as *const [G; OUT_354]) }; __ret } else { aiur_fn_354(__args, record, io_buffer, __cu)? } };
+        let __v_3: G = __r_arr[0];
+        let __v_4: G = __r_arr[1];
+        let __ret: [G; OUT_353] = [__v_3, __v_4];
+        record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      1u64 => {
-        let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { 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_17: G = __r_arr[0];
-        let __v_18: G = (__v_17 - __v_2);
-        match __v_18.as_canonical_u64() {
-          0u64 => {
-            let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_0, __v_1, __v_3, __v_5, __v_6, __v_14, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[445].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_445] = unsafe { *(result.output.as_ptr() as *const [G; OUT_445]) }; __ret } else { aiur_fn_445(__args, record, io_buffer, __cu)? } };
-            let __v_19: G = __r_arr[0];
-            let __v_20: G = __r_arr[1];
-            let __ret: [G; OUT_441] = [__v_19, __v_20];
-            record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            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 = { let __values: [G; 4] = [__v_20, __v_21, __v_22, __v_22]; 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_441] = [__v_19, __v_23];
-            record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-        }
+      3u64 => {
+        let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } else { aiur_fn_355(__args, record, io_buffer, __cu)? } };
+        let __v_3: G = __r_arr[0];
+        let __v_4: G = __r_arr[1];
+        let __ret: [G; OUT_353] = [__v_3, __v_4];
+        record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_16.as_canonical_u64()));
+        let __v_3: G = G::from_u64(0);
+        let __v_4: G = G::from_u64(0);
+        let __v_5: G = G::from_u64(0);
+        let __v_6: G = G::from_u64(0);
+        let __v_7: G = { let __values: [G; 4] = [__v_4, __v_5, __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_353] = [__v_3, __v_7];
+        record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_442: usize = 2;
-const IN_442: usize = 2;
-const OUT_442: usize = 1;
-fn aiur_fn_442(
-  inp: [G; IN_442],
+const INPUT_SIZE_354: usize = 2;
+const IN_354: usize = 2;
+const OUT_354: usize = 2;
+fn aiur_fn_354(
+  inp: [G; IN_354],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_442], ExecError> {
+) -> Result<[G; OUT_354], 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() {
-      7u64 => {
-        let __ret: [G; OUT_442] = [__v_0];
-        record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } else { aiur_fn_711(__args, record, io_buffer, __cu)? } };
+    let __v_2: G = __r_arr[0];
+    let __v_3: G = G::from_u64(6);
+    let __v_4: G = { let __a_val = __v_2.as_canonical_u64(); let __b_val = __v_3.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_4.as_canonical_u64() {
+      1u64 => {
+        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; 4] = [__v_6, __v_7, __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_354] = [__v_5, __v_9];
+        record.function_queries[354].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[189].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_189] = unsafe { *(result.output.as_ptr() as *const [G; OUT_189]) }; __ret } else { aiur_fn_189(__args, record, io_buffer, __cu)? } };
+        let __v_5: G = G::from_u64(3);
+        let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
-        let __v_7: G = __r_arr[1];
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; 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: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].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];
-        match __v_8.as_canonical_u64() {
-          2u64 => {
-            let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_6, __v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[443].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_443] = unsafe { *(result.output.as_ptr() as *const [G; OUT_443]) }; __ret } else { aiur_fn_443(__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];
-            match __v_12.as_canonical_u64() {
-              1u64 => {
-                let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } };
-                let __v_15: G = __r_arr[0];
-                let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } else { aiur_fn_320(__args, record, io_buffer, __cu)? } };
-                let __v_16: G = __r_arr[0];
-                match __v_16.as_canonical_u64() {
-                  1u64 => {
-                    let __ret: [G; OUT_442] = [__v_0];
-                    record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
-                  0u64 => {
-                    let __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_13, __v_15, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[444].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_444] = unsafe { *(result.output.as_ptr() as *const [G; OUT_444]) }; __ret } else { aiur_fn_444(__args, record, io_buffer, __cu)? } };
-                    let __v_17: G = __r_arr[0];
-                    let __ret: [G; OUT_442] = [__v_17];
-                    record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
-                  _ => {
-                    return Err(ExecError::MatchNoCase(__v_16.as_canonical_u64()));
-                  },
-                }
-              },
-              _ => {
-                let __ret: [G; OUT_442] = [__v_0];
-                record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-            }
-          },
-          _ => {
-            let __ret: [G; OUT_442] = [__v_0];
-            record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-        }
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_443: usize = 3;
-const IN_443: usize = 3;
-const OUT_443: usize = 3;
-fn aiur_fn_443(
-  inp: [G; IN_443],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_443], 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; 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_3: G = __loaded[0];
-    let __v_4: G = __loaded[1];
-    let __v_5: G = __loaded[2];
-    let __v_6: G = __loaded[3];
-    match __v_3.as_canonical_u64() {
-      2u64 => {
-        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-        let __v_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_275] = { let __args: [G; IN_275] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[275].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_275] = unsafe { *(result.output.as_ptr() as *const [G; OUT_275]) }; __ret } else { aiur_fn_275(__args, record, io_buffer, __cu)? } };
+        let __v_7: G = G::from_u64(5);
+        let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_356] = { let __args: [G; IN_356] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[356].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_356] = unsafe { *(result.output.as_ptr() as *const [G; OUT_356]) }; __ret } else { aiur_fn_356(__args, record, io_buffer, __cu)? } };
         let __v_9: G = __r_arr[0];
+        let __v_10: G = __r_arr[1];
         match __v_9.as_canonical_u64() {
-          0u64 => {
-            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 = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; 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_443] = [__v_10, __v_0, __v_13];
-            record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
           1u64 => {
-            let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { 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_10: G = __r_arr[0];
-            let __v_11: G = G::from_u64(2);
-            let __v_12: G = (__v_10 - __v_11);
-            match __v_12.as_canonical_u64() {
-              0u64 => {
-                let __v_13: G = G::from_u64(0);
-                let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_1, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-                let __v_14: G = __r_arr[0];
-                let __v_15: G = G::from_u64(1);
-                let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_1, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-                let __v_16: 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_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: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].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];
-                match __v_17.as_canonical_u64() {
-                  7u64 => {
-                    match __v_18.as_canonical_u64() {
-                      0u64 => {
-                        let __v_21: G = G::from_u64(1);
-                        let __ret: [G; OUT_443] = [__v_21, __v_14, __v_19];
-                        record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                        return Ok(__ret);
-                      },
-                      _ => {
-                        let __v_21: G = G::from_u64(0);
-                        let __v_22: G = G::from_u64(1);
-                        let __v_23: G = G::from_u64(1);
-                        let __v_24: G = { let __values: [G; 10] = [__v_22, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; 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_443] = [__v_21, __v_0, __v_24];
-                        record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                        return Ok(__ret);
-                      },
-                    }
-                  },
-                  _ => {
-                    let __v_21: G = G::from_u64(0);
-                    let __v_22: G = G::from_u64(1);
-                    let __v_23: G = G::from_u64(1);
-                    let __v_24: G = { let __values: [G; 10] = [__v_22, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; 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_443] = [__v_21, __v_0, __v_24];
-                    record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
-                }
-              },
-              _ => {
-                let __v_13: G = G::from_u64(0);
-                let __v_14: G = G::from_u64(1);
-                let __v_15: G = G::from_u64(1);
-                let __v_16: G = { let __values: [G; 10] = [__v_14, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15]; 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_443] = [__v_13, __v_0, __v_16];
-                record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-            }
+            let __v_11: G = G::from_u64(6);
+            let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } };
+            let __v_12: G = __r_arr[0];
+            let __v_13: G = G::from_u64(1);
+            let __v_14: G = G::from_u64(3);
+            let __v_15: G = G::from_u64(0);
+            let __v_16: G = { let __values: [G; 4] = [__v_14, __v_6, __v_10, __v_15]; 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_228] = { let __args: [G; IN_228] = [__v_16, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } };
+            let __v_17: G = __r_arr[0];
+            let __ret: [G; OUT_354] = [__v_13, __v_17];
+            record.function_queries[354].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
           },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64()));
+            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 = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; 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_354] = [__v_11, __v_15];
+            record.function_queries[354].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
           },
         }
       },
-      _ => {
-        let __v_7: G = G::from_u64(0);
-        let __v_8: G = G::from_u64(1);
-        let __v_9: G = G::from_u64(1);
-        let __v_10: G = { let __values: [G; 10] = [__v_8, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9]; 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_443] = [__v_7, __v_0, __v_10];
-        record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
     }
   })
 }
 
-const INPUT_SIZE_444: usize = 3;
-const IN_444: usize = 3;
-const OUT_444: usize = 1;
-fn aiur_fn_444(
-  inp: [G; IN_444],
+const INPUT_SIZE_355: usize = 2;
+const IN_355: usize = 2;
+const OUT_355: usize = 2;
+fn aiur_fn_355(
+  inp: [G; IN_355],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_444], ExecError> {
+) -> Result<[G; OUT_355], 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_273] = { let __args: [G; IN_273] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[273].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_273] = unsafe { *(result.output.as_ptr() as *const [G; OUT_273]) }; __ret } else { aiur_fn_273(__args, record, io_buffer, __cu)? } };
-    let __v_3: G = __r_arr[0];
-    let __v_4: G = G::from_u64(0);
-    let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_3, __v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } else { aiur_fn_334(__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(3);
+    let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } else { aiur_fn_711(__args, record, io_buffer, __cu)? } };
+    let __v_2: G = __r_arr[0];
+    let __v_3: G = G::from_u64(5);
+    let __v_4: G = { let __a_val = __v_2.as_canonical_u64(); let __b_val = __v_3.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_4.as_canonical_u64() {
+      1u64 => {
+        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; 4] = [__v_7, __v_0, __v_0, __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_444] = [__v_9];
-        record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __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_355] = [__v_5, __v_9];
+        record.function_queries[355].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      1u64 => {
-        let __v_7: G = G::from_u64(0);
-        let __v_8: G = G::from_u64(1);
-        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(1);
-        let __v_17: G = G::from_u64(1);
-        let __v_18: G = { let __values: [G; 10] = [__v_16, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17]; 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_19: G = { let __values: [G; 10] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_18]; 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_310] = { let __args: [G; IN_310] = [__v_1, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } else { aiur_fn_310(__args, record, io_buffer, __cu)? } };
-        let __v_20: G = __r_arr[0];
-        let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } };
-        let __v_21: G = __r_arr[0];
-        let __v_22: G = G::from_u64(2);
-        let __v_23: G = G::from_u64(1);
-        let __v_24: G = G::from_u64(1);
-        let __v_25: G = { let __values: [G; 3] = [__v_23, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_26: G = G::from_u64(0);
-        let __v_27: G = { let __values: [G; 4] = [__v_22, __v_6, __v_25, __v_26]; 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_320] = { let __args: [G; IN_320] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } else { aiur_fn_320(__args, record, io_buffer, __cu)? } };
-        let __v_28: G = __r_arr[0];
-        match __v_28.as_canonical_u64() {
+      _ => {
+        let __v_5: G = G::from_u64(3);
+        let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } };
+        let __v_6: G = __r_arr[0];
+        let __v_7: G = G::from_u64(4);
+        let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } };
+        let __v_8: G = __r_arr[0];
+        let __r_arr: [G; OUT_356] = { let __args: [G; IN_356] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[356].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_356] = unsafe { *(result.output.as_ptr() as *const [G; OUT_356]) }; __ret } else { aiur_fn_356(__args, record, io_buffer, __cu)? } };
+        let __v_9: G = __r_arr[0];
+        let __v_10: G = __r_arr[1];
+        match __v_9.as_canonical_u64() {
           1u64 => {
-            let __v_29: G = G::from_u64(3);
-            let __v_30: G = G::from_u64(0);
-            let __v_31: G = { let __values: [G; 4] = [__v_29, __v_27, __v_0, __v_30]; 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_444] = [__v_31];
-            record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __v_11: G = G::from_u64(5);
+            let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } };
+            let __v_12: G = __r_arr[0];
+            let __v_13: G = G::from_u64(1);
+            let __v_14: G = G::from_u64(3);
+            let __v_15: G = G::from_u64(0);
+            let __v_16: G = { let __values: [G; 4] = [__v_14, __v_6, __v_10, __v_15]; 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_228] = { let __args: [G; IN_228] = [__v_16, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } };
+            let __v_17: G = __r_arr[0];
+            let __ret: [G; OUT_355] = [__v_13, __v_17];
+            record.function_queries[355].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
-          0u64 => {
-            let __r_arr: [G; OUT_275] = { let __args: [G; IN_275] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[275].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_275] = unsafe { *(result.output.as_ptr() as *const [G; OUT_275]) }; __ret } else { aiur_fn_275(__args, record, io_buffer, __cu)? } };
-            let __v_29: G = __r_arr[0];
-            let __v_30: G = G::from_u64(0);
-            let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_29, __v_2, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } else { aiur_fn_334(__args, record, io_buffer, __cu)? } };
-            let __v_31: G = __r_arr[0];
-            let __v_32: G = __r_arr[1];
-            match __v_31.as_canonical_u64() {
-              0u64 => {
-                let __v_33: G = G::from_u64(3);
-                let __v_34: G = G::from_u64(0);
-                let __v_35: G = { let __values: [G; 4] = [__v_33, __v_27, __v_0, __v_34]; 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_444] = [__v_35];
-                record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              1u64 => {
-                let __v_33: G = G::from_u64(2);
-                let __v_34: G = G::from_u64(1);
-                let __v_35: G = G::from_u64(1);
-                let __v_36: G = { let __values: [G; 3] = [__v_34, __v_35, __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 = G::from_u64(0);
-                let __v_38: G = { let __values: [G; 4] = [__v_33, __v_32, __v_36, __v_37]; 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_39: G = G::from_u64(7);
-                let __v_40: G = G::from_u64(0);
-                let __v_41: G = G::from_u64(0);
-                let __v_42: G = { let __values: [G; 4] = [__v_39, __v_40, __v_21, __v_41]; 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_43: G = G::from_u64(3);
-                let __v_44: G = G::from_u64(3);
-                let __v_45: G = G::from_u64(0);
-                let __v_46: G = { let __values: [G; 4] = [__v_44, __v_38, __v_0, __v_45]; 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_47: G = G::from_u64(0);
-                let __v_48: G = { let __values: [G; 4] = [__v_43, __v_46, __v_42, __v_47]; 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_49: G = G::from_u64(3);
-                let __v_50: G = G::from_u64(0);
-                let __v_51: G = { let __values: [G; 4] = [__v_49, __v_27, __v_48, __v_50]; 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_444] = [__v_51];
-                record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              _ => {
-                return Err(ExecError::MatchNoCase(__v_31.as_canonical_u64()));
-              },
-            }
-          },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_28.as_canonical_u64()));
+            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 = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; 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_355] = [__v_11, __v_15];
+            record.function_queries[355].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
-      },
     }
   })
 }
 
-const INPUT_SIZE_445: usize = 11;
-const IN_445: usize = 11;
-const OUT_445: usize = 2;
-fn aiur_fn_445(
-  inp: [G; IN_445],
+const INPUT_SIZE_356: usize = 2;
+const IN_356: usize = 2;
+const OUT_356: usize = 2;
+fn aiur_fn_356(
+  inp: [G; IN_356],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_445], ExecError> {
+) -> Result<[G; OUT_356], 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 __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[446].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_446] = unsafe { *(result.output.as_ptr() as *const [G; OUT_446]) }; __ret } else { aiur_fn_446(__args, record, io_buffer, __cu)? } };
-    let __v_11: G = __r_arr[0];
-    let __v_12: G = __r_arr[1];
-    match __v_11.as_canonical_u64() {
-      1u64 => {
-        let __v_13: G = G::from_u64(1);
-        let __ret: [G; OUT_445] = [__v_13, __v_12];
-        record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-        let __v_13: G = __r_arr[0];
-        let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_7.as_canonical_u64() {
-  1u64 => {
-    let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_13, __v_2, __v_6, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = unsafe { *(result.output.as_ptr() as *const [G; OUT_454]) }; __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } };
-    let __v_14: G = __r_arr[0];
-    let __v_15: G = __r_arr[1];
-    match __v_14.as_canonical_u64() {
-      1u64 => {
-        break '__mc_0 [__v_15];
-      },
-      0u64 => {
-        break '__mc_0 [__v_13];
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64()));
-      },
-    }
-  },
-  0u64 => {
-    break '__mc_0 [__v_13];
-  },
-  _ => {
-    return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64()));
-  },
-}
- };
-        let __v_14: G = __mc_out___mc_0[0];
-        let __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_14, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[442].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_442] = unsafe { *(result.output.as_ptr() as *const [G; OUT_442]) }; __ret } else { aiur_fn_442(__args, record, io_buffer, __cu)? } };
-        let __v_15: G = __r_arr[0];
-        let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_15, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } };
-        let __v_16: G = __r_arr[0];
-        let __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_16, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[442].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_442] = unsafe { *(result.output.as_ptr() as *const [G; OUT_442]) }; __ret } else { aiur_fn_442(__args, record, io_buffer, __cu)? } };
-        let __v_17: G = __r_arr[0];
-        let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_17, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } else { aiur_fn_335(__args, record, io_buffer, __cu)? } };
-        let __v_18: G = __r_arr[0];
-        let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_18, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = unsafe { *(result.output.as_ptr() as *const [G; OUT_396]) }; __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } };
-        let __v_19: G = __r_arr[0];
-        let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[189].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_189] = unsafe { *(result.output.as_ptr() as *const [G; OUT_189]) }; __ret } else { aiur_fn_189(__args, record, io_buffer, __cu)? } };
-        let __v_20: G = __r_arr[0];
-        let __v_21: G = __r_arr[1];
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_20.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).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_22: G = __loaded[0];
-        let __v_23: G = __loaded[1];
-        let __v_24: G = __loaded[2];
-        let __v_25: G = __loaded[3];
-        match __v_22.as_canonical_u64() {
-          2u64 => {
-            let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_9, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-            let __v_26: G = __r_arr[0];
-            let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_26.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr };
-            let __v_27: G = __loaded[0];
-            let __v_28: G = __loaded[1];
-            let __v_29: G = __loaded[2];
-            let __v_30: G = __loaded[3];
-            let __v_31: G = __loaded[4];
-            let __v_32: G = __loaded[5];
-            let __v_33: G = __loaded[6];
-            let __v_34: G = __loaded[7];
-            let __v_35: G = __loaded[8];
-            let __v_36: G = __loaded[9];
-            let __v_37: G = __loaded[10];
-            match __v_27.as_canonical_u64() {
-              6u64 => {
-                let __r_arr: [G; OUT_797] = { let __args: [G; IN_797] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[797].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_797] = unsafe { *(result.output.as_ptr() as *const [G; OUT_797]) }; __ret } else { aiur_fn_797(__args, record, io_buffer, __cu)? } };
-                let __v_38: G = __r_arr[0];
-                let __v_39: G = { let __a_val = __v_31.as_canonical_u64(); let __b_val = __v_38.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_39.as_canonical_u64() {
+    let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = unsafe { *(result.output.as_ptr() as *const [G; OUT_377]) }; __ret } else { aiur_fn_377(__args, record, io_buffer, __cu)? } };
+    let __v_2: G = __r_arr[0];
+    let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[106].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_106] = unsafe { *(result.output.as_ptr() as *const [G; OUT_106]) }; __ret } else { aiur_fn_106(__args, record, io_buffer, __cu)? } };
+    let __v_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; 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: 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() {
+      2u64 => {
+        let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[258].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_258] = unsafe { *(result.output.as_ptr() as *const [G; OUT_258]) }; __ret } else { aiur_fn_258(__args, record, io_buffer, __cu)? } };
+        let __v_9: G = __r_arr[0];
+        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; 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: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].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];
+        match __v_10.as_canonical_u64() {
+          4u64 => {
+            match __v_13.as_canonical_u64() {
+              1u64 => {
+                let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } else { aiur_fn_711(__args, record, io_buffer, __cu)? } };
+                let __v_22: G = __r_arr[0];
+                let __v_23: G = G::from_u64(3);
+                let __v_24: G = (__v_22 - __v_23);
+                match __v_24.as_canonical_u64() {
                   0u64 => {
-                    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 = { let __values: [G; 4] = [__v_41, __v_42, __v_43, __v_43]; 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_445] = [__v_40, __v_44];
-                    record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __v_25: G = G::from_u64(1);
+                    let __v_26: G = G::from_u64(2);
+                    let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_4, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } };
+                    let __v_27: G = __r_arr[0];
+                    let __ret: [G; OUT_356] = [__v_25, __v_27];
+                    record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
-                  1u64 => {
-                    let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { 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_40: G = __r_arr[0];
-                    let __v_41: G = { let __a_val = __v_40.as_canonical_u64(); let __b_val = __v_33.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_41.as_canonical_u64() {
-                      1u64 => {
-                        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; 4] = [__v_43, __v_44, __v_45, __v_45]; 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_445] = [__v_42, __v_46];
-                        record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                        return Ok(__ret);
-                      },
-                      0u64 => {
-                        let __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_6, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[790].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_790] = unsafe { *(result.output.as_ptr() as *const [G; OUT_790]) }; __ret } else { aiur_fn_790(__args, record, io_buffer, __cu)? } };
-                        let __v_42: G = __r_arr[0];
-                        let __v_43: G = __r_arr[1];
-                        let __v_44: G = __r_arr[2];
-                        match __v_42.as_canonical_u64() {
-                          _ => {
-                            let __v_45: G = (__v_3 + __v_4);
-                            let __v_46: G = (__v_2 + __v_45);
-                            let __r_arr: [G; OUT_792] = { let __args: [G; IN_792] = [__v_1, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[792].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_792] = unsafe { *(result.output.as_ptr() as *const [G; OUT_792]) }; __ret } else { aiur_fn_792(__args, record, io_buffer, __cu)? } };
-                            let __v_47: G = __r_arr[0];
-                            let __v_48: G = (__v_40 - __v_33);
-                            let __r_arr: [G; OUT_796] = { let __args: [G; IN_796] = [__v_21, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[796].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_796] = unsafe { *(result.output.as_ptr() as *const [G; OUT_796]) }; __ret } else { aiur_fn_796(__args, record, io_buffer, __cu)? } };
-                            let __v_49: G = __r_arr[0];
-                            let __v_50: G = G::from_u64(1);
-                            let __v_51: G = (__v_5 + __v_50);
-                            let __r_arr: [G; OUT_796] = { let __args: [G; IN_796] = [__v_1, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[796].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_796] = unsafe { *(result.output.as_ptr() as *const [G; OUT_796]) }; __ret } else { aiur_fn_796(__args, record, io_buffer, __cu)? } };
-                            let __v_52: G = __r_arr[0];
-                            let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_44, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } };
-                            let __v_53: G = __r_arr[0];
-                            let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_53, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[427].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_427] = unsafe { *(result.output.as_ptr() as *const [G; OUT_427]) }; __ret } else { aiur_fn_427(__args, record, io_buffer, __cu)? } };
-                            let __v_54: G = __r_arr[0];
-                            let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_54, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[427].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_427] = unsafe { *(result.output.as_ptr() as *const [G; OUT_427]) }; __ret } else { aiur_fn_427(__args, record, io_buffer, __cu)? } };
-                            let __v_55: G = __r_arr[0];
-                            let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_55, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[427].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_427] = unsafe { *(result.output.as_ptr() as *const [G; OUT_427]) }; __ret } else { aiur_fn_427(__args, record, io_buffer, __cu)? } };
-                            let __v_56: G = __r_arr[0];
-                            let __v_57: G = G::from_u64(1);
-                            let __ret: [G; OUT_445] = [__v_57, __v_56];
-                            record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                            return Ok(__ret);
-                          },
-                        }
-                      },
-                      _ => {
-                        return Err(ExecError::MatchNoCase(__v_41.as_canonical_u64()));
-                      },
-                    }
-                  },
                   _ => {
-                    return Err(ExecError::MatchNoCase(__v_39.as_canonical_u64()));
+                    let __v_25: G = G::from_u64(0);
+                    let __v_26: G = G::from_u64(0);
+                    let __v_27: G = G::from_u64(0);
+                    let __v_28: G = G::from_u64(0);
+                    let __v_29: G = { let __values: [G; 4] = [__v_26, __v_27, __v_28, __v_28]; 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_356] = [__v_25, __v_29];
+                    record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
                   },
                 }
               },
               _ => {
-                let __r_arr: [G; OUT_448] = { let __args: [G; IN_448] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_0, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[448].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_448] = unsafe { *(result.output.as_ptr() as *const [G; OUT_448]) }; __ret } else { aiur_fn_448(__args, record, io_buffer, __cu)? } };
-                let __v_38: G = __r_arr[0];
-                let __v_39: G = __r_arr[1];
-                let __ret: [G; OUT_445] = [__v_38, __v_39];
-                record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __v_22: G = G::from_u64(0);
+                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 __v_26: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_25]; 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_356] = [__v_22, __v_26];
+                record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
           _ => {
-            let __r_arr: [G; OUT_448] = { let __args: [G; IN_448] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_0, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[448].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_448] = unsafe { *(result.output.as_ptr() as *const [G; OUT_448]) }; __ret } else { aiur_fn_448(__args, record, io_buffer, __cu)? } };
-            let __v_26: G = __r_arr[0];
-            let __v_27: G = __r_arr[1];
-            let __ret: [G; OUT_445] = [__v_26, __v_27];
-            record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __v_22: G = G::from_u64(0);
+            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 __v_26: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_25]; 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_356] = [__v_22, __v_26];
+            record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64()));
+        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 = { let __values: [G; 4] = [__v_10, __v_11, __v_12, __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_356] = [__v_9, __v_13];
+        record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_446: usize = 8;
-const IN_446: usize = 8;
-const OUT_446: usize = 2;
-fn aiur_fn_446(
-  inp: [G; IN_446],
+const INPUT_SIZE_357: usize = 5;
+const IN_357: usize = 5;
+const OUT_357: usize = 1;
+fn aiur_fn_357(
+  inp: [G; IN_357],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_446], ExecError> {
+) -> Result<[G; OUT_357], 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(2);
-    let __v_9: G = { let __a_val = __v_3.as_canonical_u64(); let __b_val = __v_8.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_9.as_canonical_u64() {
+    let __r_arr: [G; OUT_352] = { let __args: [G; IN_352] = [__v_0, __v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[352].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_352] = unsafe { *(result.output.as_ptr() as *const [G; OUT_352]) }; __ret } else { aiur_fn_352(__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() {
       1u64 => {
-        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 = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; 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_446] = [__v_10, __v_14];
-        record.function_queries[446].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = unsafe { *(result.output.as_ptr() as *const [G; OUT_377]) }; __ret } else { aiur_fn_377(__args, record, io_buffer, __cu)? } };
+        let __v_7: G = __r_arr[0];
+        let __ret: [G; OUT_357] = [__v_7];
+        record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-        let __v_10: G = __r_arr[0];
-        let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_10, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } };
-        let __v_11: G = __r_arr[0];
-        let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_11, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } else { aiur_fn_336(__args, record, io_buffer, __cu)? } };
-        let __v_12: G = __r_arr[0];
-        let __v_13: G = __r_arr[1];
-        match __v_12.as_canonical_u64() {
-          0u64 => {
-            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 = G::from_u64(0);
-            let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; 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_446] = [__v_14, __v_18];
-            record.function_queries[446].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+      2u64 => {
+        let __ret: [G; OUT_357] = [__v_6];
+        record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[258].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_258] = unsafe { *(result.output.as_ptr() as *const [G; OUT_258]) }; __ret } else { aiur_fn_258(__args, record, io_buffer, __cu)? } };
+        let __v_7: G = __r_arr[0];
+        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; 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: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].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];
+        let __v_18: G = __loaded[10];
+        let __v_19: G = __loaded[11];
+        match __v_8.as_canonical_u64() {
+          1u64 => {
+            let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[358].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_358] = unsafe { *(result.output.as_ptr() as *const [G; OUT_358]) }; __ret } else { aiur_fn_358(__args, record, io_buffer, __cu)? } };
+            let __v_20: G = __r_arr[0];
+            let __v_21: G = __r_arr[1];
+            match __v_20.as_canonical_u64() {
+              1u64 => {
+                let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_21, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = unsafe { *(result.output.as_ptr() as *const [G; OUT_377]) }; __ret } else { aiur_fn_377(__args, record, io_buffer, __cu)? } };
+                let __v_22: G = __r_arr[0];
+                let __ret: [G; OUT_357] = [__v_22];
+                record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } else { aiur_fn_307(__args, record, io_buffer, __cu)? } };
+                let __v_22: G = __r_arr[0];
+                let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_22, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } else { aiur_fn_341(__args, record, io_buffer, __cu)? } };
+                let __v_23: G = __r_arr[0];
+                let __ret: [G; OUT_357] = [__v_23];
+                record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+            }
+          },
+          2u64 => {
+            let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } };
+            let __v_20: G = __r_arr[0];
+            let __ret: [G; OUT_357] = [__v_20];
+            record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
-          1u64 => {
-            let __v_14: G = (__v_1 + __v_2);
-            let __v_15: G = G::from_u64(1);
-            let __v_16: G = (__v_14 + __v_15);
-            let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_0, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-            let __v_17: G = __r_arr[0];
-            let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_17, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } };
-            let __v_18: G = __r_arr[0];
-            let __r_arr: [G; OUT_447] = { let __args: [G; IN_447] = [__v_18, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[447].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_447] = unsafe { *(result.output.as_ptr() as *const [G; OUT_447]) }; __ret } else { aiur_fn_447(__args, record, io_buffer, __cu)? } };
-            let __v_19: G = __r_arr[0];
-            match __v_19.as_canonical_u64() {
-              0u64 => {
-                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 __v_24: G = { let __values: [G; 4] = [__v_21, __v_22, __v_23, __v_23]; 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_446] = [__v_20, __v_24];
-                record.function_queries[446].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+          4u64 => {
+            let __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = [__v_11, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[353].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_353] = unsafe { *(result.output.as_ptr() as *const [G; OUT_353]) }; __ret } else { aiur_fn_353(__args, record, io_buffer, __cu)? } };
+            let __v_20: G = __r_arr[0];
+            let __v_21: G = __r_arr[1];
+            match __v_20.as_canonical_u64() {
+              1u64 => {
+                let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_21, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = unsafe { *(result.output.as_ptr() as *const [G; OUT_377]) }; __ret } else { aiur_fn_377(__args, record, io_buffer, __cu)? } };
+                let __v_22: G = __r_arr[0];
+                let __ret: [G; OUT_357] = [__v_22];
+                record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } };
+                let __v_22: G = __r_arr[0];
+                let __ret: [G; OUT_357] = [__v_22];
+                record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
+            }
+          },
+          7u64 => {
+            let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_10, __v_11, __v_13, __v_14, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[570].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_570] = unsafe { *(result.output.as_ptr() as *const [G; OUT_570]) }; __ret } else { aiur_fn_570(__args, record, io_buffer, __cu)? } };
+            let __v_20: G = __r_arr[0];
+            let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_1, __v_3, __v_11, __v_13, __v_14, __v_12, __v_15, __v_4, __v_2, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } else { aiur_fn_364(__args, record, io_buffer, __cu)? } };
+            let __v_21: G = __r_arr[0];
+            let __v_22: G = __r_arr[1];
+            match __v_21.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_0, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-                let __v_20: G = __r_arr[0];
-                let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_20, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } else { aiur_fn_439(__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 __r_arr: [G; OUT_796] = { let __args: [G; IN_796] = [__v_0, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[796].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_796] = unsafe { *(result.output.as_ptr() as *const [G; OUT_796]) }; __ret } else { aiur_fn_796(__args, record, io_buffer, __cu)? } };
-                let __v_24: G = __r_arr[0];
-                let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_21, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } else { aiur_fn_336(__args, record, io_buffer, __cu)? } };
-                let __v_25: G = __r_arr[0];
-                let __v_26: G = __r_arr[1];
-                match __v_25.as_canonical_u64() {
-                  0u64 => {
-                    let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_21, __v_13, __v_24, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = unsafe { *(result.output.as_ptr() as *const [G; OUT_339]) }; __ret } else { aiur_fn_339(__args, record, io_buffer, __cu)? } };
-                    let __v_27: G = __r_arr[0];
-                    let __v_28: G = __r_arr[1];
-                    let __ret: [G; OUT_446] = [__v_27, __v_28];
-                    record.function_queries[446].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
+                let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_22, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = unsafe { *(result.output.as_ptr() as *const [G; OUT_377]) }; __ret } else { aiur_fn_377(__args, record, io_buffer, __cu)? } };
+                let __v_23: G = __r_arr[0];
+                let __ret: [G; OUT_357] = [__v_23];
+                record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              2u64 => {
+                match __v_16.as_canonical_u64() {
                   1u64 => {
-                    let __v_27: G = G::from_u64(1);
-                    let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_26, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } else { aiur_fn_306(__args, record, io_buffer, __cu)? } };
+                    let __v_23: G = (__v_11 + __v_13);
+                    let __v_24: G = (__v_23 + __v_14);
+                    let __v_25: G = (__v_24 + __v_12);
+                    let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_10, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } else { aiur_fn_368(__args, record, io_buffer, __cu)? } };
+                    let __v_26: G = __r_arr[0];
+                    let __v_27: G = __r_arr[1];
+                    let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_1, __v_3, __v_11, __v_13, __v_14, __v_12, __v_15, __v_22, __v_27, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[361].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_361] = unsafe { *(result.output.as_ptr() as *const [G; OUT_361]) }; __ret } else { aiur_fn_361(__args, record, io_buffer, __cu)? } };
                     let __v_28: G = __r_arr[0];
-                    let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } else { aiur_fn_338(__args, record, io_buffer, __cu)? } };
-                    let __v_29: G = __r_arr[0];
-                    let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_29, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[427].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_427] = unsafe { *(result.output.as_ptr() as *const [G; OUT_427]) }; __ret } else { aiur_fn_427(__args, record, io_buffer, __cu)? } };
-                    let __v_30: G = __r_arr[0];
-                    let __ret: [G; OUT_446] = [__v_27, __v_30];
-                    record.function_queries[446].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_357] = [__v_28];
+                    record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
-                    return Err(ExecError::MatchNoCase(__v_25.as_canonical_u64()));
+                    let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_10, __v_1, __v_3, __v_11, __v_13, __v_14, __v_12, __v_15, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[367].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_367] = unsafe { *(result.output.as_ptr() as *const [G; OUT_367]) }; __ret } else { aiur_fn_367(__args, record, io_buffer, __cu)? } };
+                    let __v_23: G = __r_arr[0];
+                    let __v_24: G = __r_arr[1];
+                    match __v_23.as_canonical_u64() {
+                      1u64 => {
+                        let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_24, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = unsafe { *(result.output.as_ptr() as *const [G; OUT_377]) }; __ret } else { aiur_fn_377(__args, record, io_buffer, __cu)? } };
+                        let __v_25: G = __r_arr[0];
+                        let __ret: [G; OUT_357] = [__v_25];
+                        record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        return Ok(__ret);
+                      },
+                      _ => {
+                        let __ret: [G; OUT_357] = [__v_22];
+                        record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        return Ok(__ret);
+                      },
+                    }
                   },
                 }
               },
               _ => {
-                return Err(ExecError::MatchNoCase(__v_19.as_canonical_u64()));
+                let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } };
+                let __v_23: G = __r_arr[0];
+                let __ret: [G; OUT_357] = [__v_23];
+                record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
               },
             }
           },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64()));
+            let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } };
+            let __v_20: G = __r_arr[0];
+            let __ret: [G; OUT_357] = [__v_20];
+            record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+        }
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_358: usize = 2;
+const IN_358: usize = 2;
+const OUT_358: usize = 2;
+fn aiur_fn_358(
+  inp: [G; IN_358],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_358], 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(0);
+    let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } else { aiur_fn_359(__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];
+    match __v_3.as_canonical_u64() {
+      1u64 => {
+        let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } else { aiur_fn_711(__args, record, io_buffer, __cu)? } };
+        let __v_8: G = __r_arr[0];
+        let __v_9: G = { let __a_val = __v_8.as_canonical_u64(); let __b_val = __v_4.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_9.as_canonical_u64() {
+          1u64 => {
+            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 = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; 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_358] = [__v_10, __v_14];
+            record.function_queries[358].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_1, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } };
+            let __v_10: G = __r_arr[0];
+            let __v_11: G = G::from_u64(8);
+            let __v_12: G = { let __values: [G; 4] = [__v_11, __v_5, __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 __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } };
+            let __v_13: G = __r_arr[0];
+            let __v_14: G = G::from_u64(1);
+            let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } };
+            let __v_15: G = __r_arr[0];
+            let __ret: [G; OUT_358] = [__v_14, __v_15];
+            record.function_queries[358].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
           },
         }
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64()));
+        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 = { let __values: [G; 4] = [__v_9, __v_10, __v_11, __v_11]; 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_358] = [__v_8, __v_12];
+        record.function_queries[358].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_447: usize = 2;
-const IN_447: usize = 2;
-const OUT_447: usize = 1;
-fn aiur_fn_447(
-  inp: [G; IN_447],
+const INPUT_SIZE_359: usize = 2;
+const IN_359: usize = 2;
+const OUT_359: usize = 5;
+fn aiur_fn_359(
+  inp: [G; IN_359],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_447], ExecError> {
+) -> Result<[G; OUT_359], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -40496,640 +31931,797 @@ fn aiur_fn_447(
     let __v_5: G = __loaded[3];
     match __v_2.as_canonical_u64() {
       4u64 => {
-        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_6: G = G::from_u64(1);
+        let __v_7: G = (__v_1 + __v_6);
+        let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } else { aiur_fn_359(__args, record, io_buffer, __cu)? } };
+        let __v_8: G = __r_arr[0];
+        let __v_9: G = __r_arr[1];
+        let __v_10: G = __r_arr[2];
+        let __v_11: G = __r_arr[3];
+        let __v_12: G = __r_arr[4];
+        let __ret: [G; OUT_359] = [__v_8, __v_9, __v_10, __v_11, __v_12];
+        record.function_queries[359].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      8u64 => {
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; 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: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].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];
         match __v_6.as_canonical_u64() {
-          4u64 => {
-            let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[189].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_189] = unsafe { *(result.output.as_ptr() as *const [G; OUT_189]) }; __ret } else { aiur_fn_189(__args, record, io_buffer, __cu)? } };
-            let __v_10: G = __r_arr[0];
-            let __v_11: G = __r_arr[1];
-            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; 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: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
-            let __v_12: G = __loaded[0];
-            let __v_13: G = __loaded[1];
-            let __v_14: G = __loaded[2];
-            let __v_15: G = __loaded[3];
-            match __v_12.as_canonical_u64() {
-              2u64 => {
-                let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_1, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-                let __v_16: G = __r_arr[0];
-                let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[273].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_273] = unsafe { *(result.output.as_ptr() as *const [G; OUT_273]) }; __ret } else { aiur_fn_273(__args, record, io_buffer, __cu)? } };
-                let __v_17: G = __r_arr[0];
-                let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_18: G = __r_arr[0];
-                match __v_18.as_canonical_u64() {
-                  0u64 => {
-                    let __v_19: G = G::from_u64(0);
-                    let __ret: [G; OUT_447] = [__v_19];
-                    record.function_queries[447].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
-                  1u64 => {
-                    let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { 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_19: G = __r_arr[0];
-                    let __v_20: G = G::from_u64(1);
-                    let __v_21: G = (__v_19 - __v_20);
-                    match __v_21.as_canonical_u64() {
-                      0u64 => {
-                        let __v_22: G = G::from_u64(0);
-                        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_11, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-                        let __v_23: 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_23.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).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_24: G = __loaded[0];
-                        let __v_25: G = __loaded[1];
-                        let __v_26: G = __loaded[2];
-                        let __v_27: G = __loaded[3];
-                        match __v_24.as_canonical_u64() {
-                          0u64 => {
-                            let __v_28: G = G::from_bool((__v_25 == G::ZERO));
-                            let __ret: [G; OUT_447] = [__v_28];
-                            record.function_queries[447].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                            return Ok(__ret);
-                          },
-                          _ => {
-                            let __v_28: G = G::from_u64(0);
-                            let __ret: [G; OUT_447] = [__v_28];
-                            record.function_queries[447].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                            return Ok(__ret);
-                          },
-                        }
-                      },
-                      _ => {
-                        let __v_22: G = G::from_u64(0);
-                        let __ret: [G; OUT_447] = [__v_22];
-                        record.function_queries[447].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                        return Ok(__ret);
-                      },
-                    }
-                  },
-                  _ => {
-                    return Err(ExecError::MatchNoCase(__v_18.as_canonical_u64()));
-                  },
-                }
+          0u64 => {
+            let __v_10: G = { let __a_val = __v_7.as_canonical_u64(); let __b_val = __v_1.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_10.as_canonical_u64() {
+              1u64 => {
+                let __v_11: G = G::from_u64(1);
+                let __v_12: G = G::from_u64(1);
+                let __v_13: G = (__v_1 - __v_12);
+                let __v_14: G = (__v_13 - __v_7);
+                let __ret: [G; OUT_359] = [__v_11, __v_1, __v_3, __v_4, __v_14];
+                record.function_queries[359].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
               },
               _ => {
+                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 __ret: [G; OUT_447] = [__v_16];
-                record.function_queries[447].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                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 __v_24: G = G::from_u64(0);
+                let __v_25: G = G::from_u64(0);
+                let __v_26: G = G::from_u64(0);
+                let __v_27: G = G::from_u64(0);
+                let __v_28: G = G::from_u64(0);
+                let __v_29: G = G::from_u64(0);
+                let __v_30: G = G::from_u64(0);
+                let __v_31: G = G::from_u64(0);
+                let __v_32: G = G::from_u64(0);
+                let __v_33: G = G::from_u64(0);
+                let __v_34: G = G::from_u64(0);
+                let __v_35: G = G::from_u64(0);
+                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; 32] = [__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]; 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_46: G = G::from_u64(0);
+                let __v_47: G = G::from_u64(0);
+                let __ret: [G; OUT_359] = [__v_11, __v_12, __v_45, __v_46, __v_47];
+                record.function_queries[359].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
           _ => {
             let __v_10: G = G::from_u64(0);
-            let __ret: [G; OUT_447] = [__v_10];
-            record.function_queries[447].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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 = 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 __v_24: G = G::from_u64(0);
+            let __v_25: G = G::from_u64(0);
+            let __v_26: G = G::from_u64(0);
+            let __v_27: G = G::from_u64(0);
+            let __v_28: G = G::from_u64(0);
+            let __v_29: G = G::from_u64(0);
+            let __v_30: G = G::from_u64(0);
+            let __v_31: G = G::from_u64(0);
+            let __v_32: G = G::from_u64(0);
+            let __v_33: G = G::from_u64(0);
+            let __v_34: G = G::from_u64(0);
+            let __v_35: G = G::from_u64(0);
+            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 = { let __values: [G; 32] = [__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]; 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_45: G = G::from_u64(0);
+            let __v_46: G = G::from_u64(0);
+            let __ret: [G; OUT_359] = [__v_10, __v_11, __v_44, __v_45, __v_46];
+            record.function_queries[359].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
       _ => {
         let __v_6: G = G::from_u64(0);
-        let __ret: [G; OUT_447] = [__v_6];
-        record.function_queries[447].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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 __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 = 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 __v_24: G = G::from_u64(0);
+        let __v_25: G = G::from_u64(0);
+        let __v_26: G = G::from_u64(0);
+        let __v_27: G = G::from_u64(0);
+        let __v_28: G = G::from_u64(0);
+        let __v_29: G = G::from_u64(0);
+        let __v_30: G = G::from_u64(0);
+        let __v_31: G = G::from_u64(0);
+        let __v_32: G = G::from_u64(0);
+        let __v_33: G = G::from_u64(0);
+        let __v_34: G = G::from_u64(0);
+        let __v_35: G = G::from_u64(0);
+        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 = { let __values: [G; 32] = [__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, __v_37, __v_38, __v_39]; 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_41: G = G::from_u64(0);
+        let __v_42: G = G::from_u64(0);
+        let __ret: [G; OUT_359] = [__v_6, __v_7, __v_40, __v_41, __v_42];
+        record.function_queries[359].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_448: usize = 10;
-const IN_448: usize = 10;
-const OUT_448: usize = 2;
-fn aiur_fn_448(
-  inp: [G; IN_448],
+const INPUT_SIZE_360: usize = 1;
+const IN_360: usize = 1;
+const OUT_360: usize = 1;
+fn aiur_fn_360(
+  inp: [G; IN_360],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_448], ExecError> {
+) -> Result<[G; OUT_360], 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 __r_arr: [G; OUT_797] = { let __args: [G; IN_797] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[797].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_797] = unsafe { *(result.output.as_ptr() as *const [G; OUT_797]) }; __ret } else { aiur_fn_797(__args, record, io_buffer, __cu)? } };
-    let __v_10: G = __r_arr[0];
-    match __v_10.as_canonical_u64() {
-      1u64 => {
-        let __v_11: G = G::from_u64(0);
-        let __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_5, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[790].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_790] = unsafe { *(result.output.as_ptr() as *const [G; OUT_790]) }; __ret } else { aiur_fn_790(__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];
-        match __v_12.as_canonical_u64() {
-          _ => {
-            let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_8, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-            let __v_15: G = __r_arr[0];
-            let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr };
-            let __v_16: G = __loaded[0];
-            let __v_17: G = __loaded[1];
-            let __v_18: G = __loaded[2];
-            let __v_19: G = __loaded[3];
-            let __v_20: G = __loaded[4];
-            let __v_21: G = __loaded[5];
-            let __v_22: G = __loaded[6];
-            let __v_23: G = __loaded[7];
-            let __v_24: G = __loaded[8];
-            let __v_25: G = __loaded[9];
-            let __v_26: G = __loaded[10];
-            match __v_16.as_canonical_u64() {
-              6u64 => {
-                let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_8, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-                let __v_27: G = __r_arr[0];
-                let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr };
-                let __v_28: G = __loaded[0];
-                let __v_29: G = __loaded[1];
-                let __v_30: G = __loaded[2];
-                let __v_31: G = __loaded[3];
-                let __v_32: G = __loaded[4];
-                let __v_33: G = __loaded[5];
-                let __v_34: G = __loaded[6];
-                let __v_35: G = __loaded[7];
-                let __v_36: G = __loaded[8];
-                let __v_37: G = __loaded[9];
-                let __v_38: G = __loaded[10];
-                match __v_28.as_canonical_u64() {
-                  5u64 => {
-                    let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { 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_39: G = __r_arr[0];
-                    match __v_39.as_canonical_u64() {
-                      1u64 => {
-                        match __v_32.as_canonical_u64() {
-                          0u64 => {
-                            let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_19, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } else { aiur_fn_529(__args, record, io_buffer, __cu)? } };
-                            let __v_40: G = __r_arr[0];
-                            match __v_40.as_canonical_u64() {
-                              0u64 => {
-                                let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-                                let __v_41: G = __r_arr[0];
-                                let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_41, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[459].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_459] = unsafe { *(result.output.as_ptr() as *const [G; OUT_459]) }; __ret } else { aiur_fn_459(__args, record, io_buffer, __cu)? } };
-                                let __v_42: G = __r_arr[0];
-                                let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_42, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } };
-                                let __v_43: G = __r_arr[0];
-                                match __v_43.as_canonical_u64() {
-                                  1u64 => {
-                                    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; 4] = [__v_45, __v_46, __v_47, __v_47]; 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_448] = [__v_44, __v_48];
-                                    record.function_queries[448].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                    return Ok(__ret);
-                                  },
-                                  0u64 => {
-                                    let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_14, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } };
-                                    let __v_44: G = __r_arr[0];
-                                    let __v_45: G = (__v_1 + __v_2);
-                                    let __v_46: G = (__v_45 + __v_3);
-                                    let __r_arr: [G; OUT_792] = { let __args: [G; IN_792] = [__v_0, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[792].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_792] = unsafe { *(result.output.as_ptr() as *const [G; OUT_792]) }; __ret } else { aiur_fn_792(__args, record, io_buffer, __cu)? } };
-                                    let __v_47: G = __r_arr[0];
-                                    let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_44, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[427].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_427] = unsafe { *(result.output.as_ptr() as *const [G; OUT_427]) }; __ret } else { aiur_fn_427(__args, record, io_buffer, __cu)? } };
-                                    let __v_48: G = __r_arr[0];
-                                    let __v_49: G = G::from_u64(0);
-                                    let __r_arr: [G; OUT_453] = { let __args: [G; IN_453] = [__v_48, __v_19, __v_41, __v_13, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[453].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_453] = unsafe { *(result.output.as_ptr() as *const [G; OUT_453]) }; __ret } else { aiur_fn_453(__args, record, io_buffer, __cu)? } };
-                                    let __v_50: G = __r_arr[0];
-                                    let __v_51: G = G::from_u64(1);
-                                    let __v_52: G = (__v_4 + __v_51);
-                                    let __r_arr: [G; OUT_796] = { let __args: [G; IN_796] = [__v_0, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[796].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_796] = unsafe { *(result.output.as_ptr() as *const [G; OUT_796]) }; __ret } else { aiur_fn_796(__args, record, io_buffer, __cu)? } };
-                                    let __v_53: G = __r_arr[0];
-                                    let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_50, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[427].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_427] = unsafe { *(result.output.as_ptr() as *const [G; OUT_427]) }; __ret } else { aiur_fn_427(__args, record, io_buffer, __cu)? } };
-                                    let __v_54: G = __r_arr[0];
-                                    let __v_55: G = G::from_u64(1);
-                                    let __ret: [G; OUT_448] = [__v_55, __v_54];
-                                    record.function_queries[448].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                    return Ok(__ret);
-                                  },
-                                  _ => {
-                                    return Err(ExecError::MatchNoCase(__v_43.as_canonical_u64()));
-                                  },
-                                }
-                              },
-                              _ => {
-                                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; 4] = [__v_42, __v_43, __v_44, __v_44]; 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_448] = [__v_41, __v_45];
-                                record.function_queries[448].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                return Ok(__ret);
-                              },
-                            }
-                          },
-                          _ => {
-                            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 = { let __values: [G; 4] = [__v_41, __v_42, __v_43, __v_43]; 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_448] = [__v_40, __v_44];
-                            record.function_queries[448].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                            return Ok(__ret);
-                          },
-                        }
-                      },
-                      _ => {
-                        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 = { let __values: [G; 4] = [__v_41, __v_42, __v_43, __v_43]; 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_448] = [__v_40, __v_44];
-                        record.function_queries[448].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                        return Ok(__ret);
-                      },
-                    }
-                  },
-                  _ => {
-                    return Err(ExecError::MatchNoCase(__v_28.as_canonical_u64()));
-                  },
-                }
+    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() {
+      7u64 => {
+        match __v_2.as_canonical_u64() {
+          0u64 => {
+            let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { 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_5: G = __r_arr[0];
+            match __v_5.as_canonical_u64() {
+              1u64 => {
+                let __v_6: G = G::from_u64(2);
+                let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[138].get_mut(&__args[..]) { 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_7: G = __r_arr[0];
+                let __v_8: G = G::from_u64(1);
+                let __v_9: G = G::from_u64(1);
+                let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __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 = G::from_u64(0);
+                let __v_12: G = { let __values: [G; 4] = [__v_6, __v_7, __v_10, __v_11]; 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_360] = [__v_12];
+                record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
               },
               _ => {
-                return Err(ExecError::MatchNoCase(__v_16.as_canonical_u64()));
+                let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { 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_7: G = __r_arr[0];
+                let __v_8: G = G::from_u64(7);
+                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_7, __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 __v_12: G = G::from_u64(2);
+                let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[139].get_mut(&__args[..]) { 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_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 __v_17: G = G::from_u64(0);
+                let __v_18: G = { let __values: [G; 4] = [__v_12, __v_13, __v_16, __v_17]; 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_19: G = G::from_u64(3);
+                let __v_20: G = G::from_u64(0);
+                let __v_21: G = { let __values: [G; 4] = [__v_19, __v_18, __v_11, __v_20]; 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_360] = [__v_21];
+                record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
               },
             }
           },
-        }
-      },
-      _ => {
-        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 = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; 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_448] = [__v_11, __v_15];
-        record.function_queries[448].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_449: usize = 5;
-const IN_449: usize = 5;
-const OUT_449: usize = 2;
-fn aiur_fn_449(
-  inp: [G; IN_449],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_449], 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() {
-      2u64 => {
-        let __r_arr: [G; OUT_450] = { let __args: [G; IN_450] = [__v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[450].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_450] = unsafe { *(result.output.as_ptr() as *const [G; OUT_450]) }; __ret } else { aiur_fn_450(__args, record, io_buffer, __cu)? } };
-        let __v_5: G = __r_arr[0];
-        let __v_6: G = __r_arr[1];
-        let __ret: [G; OUT_449] = [__v_5, __v_6];
-        record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      3u64 => {
-        let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[451].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_451] = unsafe { *(result.output.as_ptr() as *const [G; OUT_451]) }; __ret } else { aiur_fn_451(__args, record, io_buffer, __cu)? } };
-        let __v_5: G = __r_arr[0];
-        let __v_6: G = __r_arr[1];
-        let __ret: [G; OUT_449] = [__v_5, __v_6];
-        record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
+          _ => {
+            let __ret: [G; OUT_360] = [__v_0];
+            record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+        }
       },
       _ => {
-        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; 4] = [__v_6, __v_7, __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_449] = [__v_5, __v_9];
-        record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_360] = [__v_0];
+        record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_450: usize = 4;
-const IN_450: usize = 4;
-const OUT_450: usize = 2;
-fn aiur_fn_450(
-  inp: [G; IN_450],
+const INPUT_SIZE_361: usize = 10;
+const IN_361: usize = 10;
+const OUT_361: usize = 1;
+fn aiur_fn_361(
+  inp: [G; IN_361],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_450], ExecError> {
+) -> Result<[G; OUT_361], 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_187] = { let __args: [G; IN_187] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { 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_4: G = __r_arr[0];
-    let __v_5: G = G::from_u64(6);
-    let __v_6: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_5.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_6.as_canonical_u64() {
-      1u64 => {
-        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 = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __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_450] = [__v_7, __v_11];
-        record.function_queries[450].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
+    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 __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; 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: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].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];
+    match __v_10.as_canonical_u64() {
       0u64 => {
-        let __v_7: G = G::from_u64(3);
-        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-        let __v_8: G = __r_arr[0];
-        let __v_9: G = G::from_u64(5);
-        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-        let __v_10: G = __r_arr[0];
-        let __r_arr: [G; OUT_452] = { let __args: [G; IN_452] = [__v_10, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[452].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_452] = unsafe { *(result.output.as_ptr() as *const [G; OUT_452]) }; __ret } else { aiur_fn_452(__args, record, io_buffer, __cu)? } };
-        let __v_11: G = __r_arr[0];
-        let __v_12: G = __r_arr[1];
         match __v_11.as_canonical_u64() {
-          1u64 => {
-            let __v_13: G = G::from_u64(6);
-            let __r_arr: [G; OUT_796] = { let __args: [G; IN_796] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[796].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_796] = unsafe { *(result.output.as_ptr() as *const [G; OUT_796]) }; __ret } else { aiur_fn_796(__args, record, io_buffer, __cu)? } };
-            let __v_14: G = __r_arr[0];
-            let __v_15: G = G::from_u64(3);
-            let __v_16: G = G::from_u64(0);
-            let __v_17: G = { let __values: [G; 4] = [__v_15, __v_8, __v_12, __v_16]; 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_427] = { let __args: [G; IN_427] = [__v_17, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[427].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_427] = unsafe { *(result.output.as_ptr() as *const [G; OUT_427]) }; __ret } else { aiur_fn_427(__args, record, io_buffer, __cu)? } };
-            let __v_18: G = __r_arr[0];
-            let __v_19: G = G::from_u64(1);
-            let __ret: [G; OUT_450] = [__v_19, __v_18];
-            record.function_queries[450].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          0u64 => {
-            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; 4] = [__v_14, __v_15, __v_16, __v_16]; 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_450] = [__v_13, __v_17];
-            record.function_queries[450].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64()));
+            let __v_15: G = (__v_4 + __v_5);
+            let __v_16: G = (__v_3 + __v_15);
+            let __v_17: G = (__v_2 + __v_16);
+            let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_1, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } };
+            let __v_18: G = __r_arr[0];
+            let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_18, __v_11, __v_2, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[362].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_362] = unsafe { *(result.output.as_ptr() as *const [G; OUT_362]) }; __ret } else { aiur_fn_362(__args, record, io_buffer, __cu)? } };
+            let __v_19: G = __r_arr[0];
+            match __v_19.as_canonical_u64() {
+              0u64 => {
+                let __ret: [G; OUT_361] = [__v_7];
+                record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_13, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } else { aiur_fn_307(__args, record, io_buffer, __cu)? } };
+                let __v_20: G = __r_arr[0];
+                let __v_21: G = (__v_3 + __v_4);
+                let __v_22: G = (__v_2 + __v_21);
+                let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_1, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } else { aiur_fn_721(__args, record, io_buffer, __cu)? } };
+                let __v_23: G = __r_arr[0];
+                let __v_24: G = G::from_u64(1);
+                let __v_25: G = (__v_17 + __v_24);
+                let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_1, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } };
+                let __v_26: G = __r_arr[0];
+                let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_20, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } };
+                let __v_27: G = __r_arr[0];
+                let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_27, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } };
+                let __v_28: G = __r_arr[0];
+                let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_28, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = unsafe { *(result.output.as_ptr() as *const [G; OUT_377]) }; __ret } else { aiur_fn_377(__args, record, io_buffer, __cu)? } };
+                let __v_29: G = __r_arr[0];
+                let __ret: [G; OUT_361] = [__v_29];
+                record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+            }
           },
         }
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64()));
+        let __ret: [G; OUT_361] = [__v_7];
+        record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_451: usize = 4;
-const IN_451: usize = 4;
-const OUT_451: usize = 2;
-fn aiur_fn_451(
-  inp: [G; IN_451],
+const INPUT_SIZE_362: usize = 5;
+const IN_362: usize = 5;
+const OUT_362: usize = 1;
+fn aiur_fn_362(
+  inp: [G; IN_362],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_451], ExecError> {
+) -> Result<[G; OUT_362], 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_187] = { let __args: [G; IN_187] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { 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_4: G = __r_arr[0];
-    let __v_5: G = G::from_u64(5);
-    let __v_6: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_5.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_6.as_canonical_u64() {
-      1u64 => {
-        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 = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __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_451] = [__v_7, __v_11];
-        record.function_queries[451].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __v_7: G = G::from_u64(3);
-        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-        let __v_8: G = __r_arr[0];
-        let __v_9: G = G::from_u64(4);
-        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-        let __v_10: G = __r_arr[0];
-        let __r_arr: [G; OUT_452] = { let __args: [G; IN_452] = [__v_10, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[452].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_452] = unsafe { *(result.output.as_ptr() as *const [G; OUT_452]) }; __ret } else { aiur_fn_452(__args, record, io_buffer, __cu)? } };
-        let __v_11: G = __r_arr[0];
-        let __v_12: G = __r_arr[1];
-        match __v_11.as_canonical_u64() {
-          1u64 => {
-            let __v_13: G = G::from_u64(5);
-            let __r_arr: [G; OUT_796] = { let __args: [G; IN_796] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[796].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_796] = unsafe { *(result.output.as_ptr() as *const [G; OUT_796]) }; __ret } else { aiur_fn_796(__args, record, io_buffer, __cu)? } };
-            let __v_14: G = __r_arr[0];
-            let __v_15: G = G::from_u64(3);
-            let __v_16: G = G::from_u64(0);
-            let __v_17: G = { let __values: [G; 4] = [__v_15, __v_8, __v_12, __v_16]; 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_427] = { let __args: [G; IN_427] = [__v_17, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[427].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_427] = unsafe { *(result.output.as_ptr() as *const [G; OUT_427]) }; __ret } else { aiur_fn_427(__args, record, io_buffer, __cu)? } };
-            let __v_18: G = __r_arr[0];
-            let __v_19: G = G::from_u64(1);
-            let __ret: [G; OUT_451] = [__v_19, __v_18];
-            record.function_queries[451].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
+    let __v_4: G = inp[4];
+    let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[434].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_434] = unsafe { *(result.output.as_ptr() as *const [G; OUT_434]) }; __ret } else { aiur_fn_434(__args, record, io_buffer, __cu)? } };
+    let __v_5: G = __r_arr[0];
+    let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_5, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = unsafe { *(result.output.as_ptr() as *const [G; OUT_377]) }; __ret } else { aiur_fn_377(__args, record, io_buffer, __cu)? } };
+    let __v_6: G = __r_arr[0];
+    let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[106].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_106] = unsafe { *(result.output.as_ptr() as *const [G; OUT_106]) }; __ret } else { aiur_fn_106(__args, record, io_buffer, __cu)? } };
+    let __v_7: G = __r_arr[0];
+    let __v_8: G = __r_arr[1];
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; 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: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].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];
+    match __v_9.as_canonical_u64() {
+      2u64 => {
+        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_10, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_13: G = __r_arr[0];
+        match __v_13.as_canonical_u64() {
           0u64 => {
-            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; 4] = [__v_14, __v_15, __v_16, __v_16]; 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_451] = [__v_13, __v_17];
-            record.function_queries[451].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_362] = [__v_14];
+            record.function_queries[362].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64()));
+            let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[258].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_258] = unsafe { *(result.output.as_ptr() as *const [G; OUT_258]) }; __ret } else { aiur_fn_258(__args, record, io_buffer, __cu)? } };
+            let __v_14: G = __r_arr[0];
+            let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+            let __v_15: G = __loaded[0];
+            let __v_16: G = __loaded[1];
+            let __v_17: G = __loaded[2];
+            let __v_18: G = __loaded[3];
+            let __v_19: G = __loaded[4];
+            let __v_20: G = __loaded[5];
+            let __v_21: G = __loaded[6];
+            let __v_22: G = __loaded[7];
+            let __v_23: G = __loaded[8];
+            let __v_24: G = __loaded[9];
+            let __v_25: G = __loaded[10];
+            let __v_26: G = __loaded[11];
+            match __v_15.as_canonical_u64() {
+              5u64 => {
+                let __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = [__v_22, __v_23, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[502].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_502] = unsafe { *(result.output.as_ptr() as *const [G; OUT_502]) }; __ret } else { aiur_fn_502(__args, record, io_buffer, __cu)? } };
+                let __v_27: G = __r_arr[0];
+                let __v_28: G = G::from_u64(2);
+                let __v_29: G = G::from_u64(0);
+                let __v_30: G = { let __values: [G; 4] = [__v_28, __v_27, __v_11, __v_29]; 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_721] = { let __args: [G; IN_721] = [__v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } else { aiur_fn_721(__args, record, io_buffer, __cu)? } };
+                let __v_31: G = __r_arr[0];
+                let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } };
+                let __v_32: G = __r_arr[0];
+                let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_32, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[434].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_434] = unsafe { *(result.output.as_ptr() as *const [G; OUT_434]) }; __ret } else { aiur_fn_434(__args, record, io_buffer, __cu)? } };
+                let __v_33: G = __r_arr[0];
+                let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_6, __v_33, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } };
+                let __v_34: G = __r_arr[0];
+                let __ret: [G; OUT_362] = [__v_34];
+                record.function_queries[362].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                let __v_27: G = G::from_u64(0);
+                let __ret: [G; OUT_362] = [__v_27];
+                record.function_queries[362].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+            }
           },
         }
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64()));
+        let __v_13: G = G::from_u64(0);
+        let __ret: [G; OUT_362] = [__v_13];
+        record.function_queries[362].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_452: usize = 4;
-const IN_452: usize = 4;
-const OUT_452: usize = 2;
-fn aiur_fn_452(
-  inp: [G; IN_452],
+const INPUT_SIZE_363: usize = 3;
+const IN_363: usize = 3;
+const OUT_363: usize = 1;
+fn aiur_fn_363(
+  inp: [G; IN_363],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_452], ExecError> {
+) -> Result<[G; OUT_363], 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_721] = { let __args: [G; IN_721] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } else { aiur_fn_721(__args, record, io_buffer, __cu)? } };
+    let __v_3: G = __r_arr[0];
+    let __v_4: G = G::from_u64(1);
+    let __v_5: G = (__v_1 + __v_4);
+    let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } };
+    let __v_6: G = __r_arr[0];
+    let __v_7: G = G::from_u64(0);
+    let __v_8: G = G::from_u64(1);
+    let __v_9: G = G::from_u64(1);
+    let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __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_7, __v_2, __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_710] = { let __args: [G; IN_710] = [__v_3, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[710].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_710] = unsafe { *(result.output.as_ptr() as *const [G; OUT_710]) }; __ret } else { aiur_fn_710(__args, record, io_buffer, __cu)? } };
+    let __v_12: G = __r_arr[0];
+    let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_12, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[710].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_710] = unsafe { *(result.output.as_ptr() as *const [G; OUT_710]) }; __ret } else { aiur_fn_710(__args, record, io_buffer, __cu)? } };
+    let __v_13: G = __r_arr[0];
+    let __ret: [G; OUT_363] = [__v_13];
+    record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_364: usize = 10;
+const IN_364: usize = 10;
+const OUT_364: usize = 2;
+fn aiur_fn_364(
+  inp: [G; IN_364],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_364], 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_439] = { let __args: [G; IN_439] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } };
-    let __v_4: G = __r_arr[0];
-    let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[189].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_189] = unsafe { *(result.output.as_ptr() as *const [G; OUT_189]) }; __ret } else { aiur_fn_189(__args, record, io_buffer, __cu)? } };
-    let __v_5: G = __r_arr[0];
-    let __v_6: G = __r_arr[1];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; 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: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].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];
-    match __v_7.as_canonical_u64() {
-      2u64 => {
-        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_2, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-        let __v_11: G = __r_arr[0];
-        let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr };
-        let __v_12: G = __loaded[0];
-        let __v_13: G = __loaded[1];
-        let __v_14: G = __loaded[2];
-        let __v_15: G = __loaded[3];
-        let __v_16: G = __loaded[4];
-        let __v_17: G = __loaded[5];
-        let __v_18: G = __loaded[6];
-        let __v_19: G = __loaded[7];
-        let __v_20: G = __loaded[8];
-        let __v_21: G = __loaded[9];
-        let __v_22: G = __loaded[10];
-        match __v_12.as_canonical_u64() {
-          4u64 => {
-            match __v_15.as_canonical_u64() {
+    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_4 + __v_5);
+    let __v_11: G = (__v_3 + __v_10);
+    let __v_12: G = (__v_2 + __v_11);
+    let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } else { aiur_fn_711(__args, record, io_buffer, __cu)? } };
+    let __v_13: G = __r_arr[0];
+    let __v_14: G = { let __a_val = __v_12.as_canonical_u64(); let __b_val = __v_13.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_14.as_canonical_u64() {
+      0u64 => {
+        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 = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; 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_364] = [__v_15, __v_19];
+        record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_1, __v_2, __v_3, __v_4, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[235].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_235] = unsafe { *(result.output.as_ptr() as *const [G; OUT_235]) }; __ret } else { aiur_fn_235(__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() {
+          1u64 => {
+            let __v_17: G = G::from_u64(1);
+            let __ret: [G; OUT_364] = [__v_17, __v_16];
+            record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } };
+            let __v_17: G = __r_arr[0];
+            let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[232].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_232] = unsafe { *(result.output.as_ptr() as *const [G; OUT_232]) }; __ret } else { aiur_fn_232(__args, record, io_buffer, __cu)? } };
+            let __v_18: G = __r_arr[0];
+            let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_18, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = unsafe { *(result.output.as_ptr() as *const [G; OUT_377]) }; __ret } else { aiur_fn_377(__args, record, io_buffer, __cu)? } };
+            let __v_19: G = __r_arr[0];
+            let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[232].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_232] = unsafe { *(result.output.as_ptr() as *const [G; OUT_232]) }; __ret } else { aiur_fn_232(__args, record, io_buffer, __cu)? } };
+            let __v_20: G = __r_arr[0];
+            let __r_arr: [G; OUT_360] = { let __args: [G; IN_360] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[360].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_360] = unsafe { *(result.output.as_ptr() as *const [G; OUT_360]) }; __ret } else { aiur_fn_360(__args, record, io_buffer, __cu)? } };
+            let __v_21: G = __r_arr[0];
+            let __r_arr: [G; OUT_365] = { let __args: [G; IN_365] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[365].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_365] = unsafe { *(result.output.as_ptr() as *const [G; OUT_365]) }; __ret } else { aiur_fn_365(__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];
+            match __v_22.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { 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_23: G = __r_arr[0];
-                let __v_24: G = G::from_u64(3);
-                let __v_25: G = (__v_23 - __v_24);
-                match __v_25.as_canonical_u64() {
+                let __r_arr: [G; OUT_366] = { let __args: [G; IN_366] = [__v_6, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[366].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_366] = unsafe { *(result.output.as_ptr() as *const [G; OUT_366]) }; __ret } else { aiur_fn_366(__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 __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_24, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_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: Some("iota: major's constructor belongs to a different inductive".to_string()) });
+                }
+                match __v_26.as_canonical_u64() {
                   0u64 => {
-                    let __v_26: G = G::from_u64(2);
-                    let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_6, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-                    let __v_27: G = __r_arr[0];
-                    let __v_28: G = G::from_u64(1);
-                    let __ret: [G; OUT_452] = [__v_28, __v_27];
-                    record.function_queries[452].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_1, __v_12, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[363].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_363] = unsafe { *(result.output.as_ptr() as *const [G; OUT_363]) }; __ret } else { aiur_fn_363(__args, record, io_buffer, __cu)? } };
+                    let __v_31: G = __r_arr[0];
+                    let __v_32: G = G::from_u64(2);
+                    let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_8, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } };
+                    let __v_33: G = __r_arr[0];
+                    let __ret: [G; OUT_364] = [__v_32, __v_33];
+                    record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
-                  _ => {
-                    let __v_26: G = G::from_u64(0);
-                    let __v_27: G = G::from_u64(0);
-                    let __v_28: G = G::from_u64(0);
-                    let __v_29: G = G::from_u64(0);
-                    let __v_30: G = { let __values: [G; 4] = [__v_27, __v_28, __v_29, __v_29]; 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_452] = [__v_26, __v_30];
-                    record.function_queries[452].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                  1u64 => {
+                    let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_28, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } else { aiur_fn_307(__args, record, io_buffer, __cu)? } };
+                    let __v_31: G = __r_arr[0];
+                    let __v_32: G = (__v_3 + __v_4);
+                    let __v_33: G = (__v_2 + __v_32);
+                    let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_1, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } else { aiur_fn_721(__args, record, io_buffer, __cu)? } };
+                    let __v_34: G = __r_arr[0];
+                    let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } else { aiur_fn_711(__args, record, io_buffer, __cu)? } };
+                    let __v_35: G = __r_arr[0];
+                    let __v_36: G = (__v_35 - __v_27);
+                    let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_25, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } };
+                    let __v_37: G = __r_arr[0];
+                    let __v_38: G = G::from_u64(1);
+                    let __v_39: G = (__v_12 + __v_38);
+                    let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_1, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } };
+                    let __v_40: G = __r_arr[0];
+                    let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_31, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } };
+                    let __v_41: G = __r_arr[0];
+                    let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_41, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } };
+                    let __v_42: G = __r_arr[0];
+                    let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_42, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } };
+                    let __v_43: G = __r_arr[0];
+                    let __v_44: G = G::from_u64(1);
+                    let __ret: [G; OUT_364] = [__v_44, __v_43];
+                    record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
+                  _ => {
+                    return Err(ExecError::MatchNoCase(__v_26.as_canonical_u64()));
+                  },
                 }
               },
               _ => {
-                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 __v_26: G = G::from_u64(0);
-                let __v_27: G = { let __values: [G; 4] = [__v_24, __v_25, __v_26, __v_26]; 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_452] = [__v_23, __v_27];
-                record.function_queries[452].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_1, __v_12, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[363].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_363] = unsafe { *(result.output.as_ptr() as *const [G; OUT_363]) }; __ret } else { aiur_fn_363(__args, record, io_buffer, __cu)? } };
+                let __v_26: G = __r_arr[0];
+                let __v_27: G = G::from_u64(2);
+                let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_8, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } };
+                let __v_28: G = __r_arr[0];
+                let __ret: [G; OUT_364] = [__v_27, __v_28];
+                record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
+        }
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_365: usize = 1;
+const IN_365: usize = 1;
+const OUT_365: usize = 4;
+fn aiur_fn_365(
+  inp: [G; IN_365],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_365], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[106].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_106] = unsafe { *(result.output.as_ptr() as *const [G; OUT_106]) }; __ret } else { aiur_fn_106(__args, record, io_buffer, __cu)? } };
+    let __v_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    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_3: G = __loaded[0];
+    let __v_4: G = __loaded[1];
+    let __v_5: G = __loaded[2];
+    let __v_6: G = __loaded[3];
+    match __v_3.as_canonical_u64() {
+      2u64 => {
+        let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[258].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_258] = unsafe { *(result.output.as_ptr() as *const [G; OUT_258]) }; __ret } else { aiur_fn_258(__args, record, io_buffer, __cu)? } };
+        let __v_7: G = __r_arr[0];
+        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; 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: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].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];
+        let __v_18: G = __loaded[10];
+        let __v_19: G = __loaded[11];
+        match __v_8.as_canonical_u64() {
+          6u64 => {
+            let __v_20: G = G::from_u64(1);
+            let __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[410].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_410] = unsafe { *(result.output.as_ptr() as *const [G; OUT_410]) }; __ret } else { aiur_fn_410(__args, record, io_buffer, __cu)? } };
+            let __v_21: G = __r_arr[0];
+            let __ret: [G; OUT_365] = [__v_20, __v_13, __v_21, __v_2];
+            record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
           _ => {
+            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 __v_24: G = G::from_u64(0);
             let __v_25: G = G::from_u64(0);
             let __v_26: G = G::from_u64(0);
-            let __v_27: G = { let __values: [G; 4] = [__v_24, __v_25, __v_26, __v_26]; 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_452] = [__v_23, __v_27];
-            record.function_queries[452].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __v_27: G = G::from_u64(0);
+            let __v_28: G = G::from_u64(0);
+            let __v_29: G = G::from_u64(0);
+            let __v_30: G = G::from_u64(0);
+            let __v_31: G = G::from_u64(0);
+            let __v_32: G = G::from_u64(0);
+            let __v_33: G = G::from_u64(0);
+            let __v_34: G = G::from_u64(0);
+            let __v_35: G = G::from_u64(0);
+            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 = 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 = G::from_u64(0);
+            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 = { let __values: [G; 32] = [__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]; 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_55: G = G::from_u64(1);
+            let __v_56: G = G::from_u64(1);
+            let __v_57: G = { let __values: [G; 3] = [__v_55, __v_56, __v_56]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_365] = [__v_20, __v_21, __v_54, __v_57];
+            record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
       _ => {
+        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 __v_13: G = G::from_u64(0);
         let __v_14: G = G::from_u64(0);
-        let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; 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_452] = [__v_11, __v_15];
-        record.function_queries[452].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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 __v_24: G = G::from_u64(0);
+        let __v_25: G = G::from_u64(0);
+        let __v_26: G = G::from_u64(0);
+        let __v_27: G = G::from_u64(0);
+        let __v_28: G = G::from_u64(0);
+        let __v_29: G = G::from_u64(0);
+        let __v_30: G = G::from_u64(0);
+        let __v_31: G = G::from_u64(0);
+        let __v_32: G = G::from_u64(0);
+        let __v_33: G = G::from_u64(0);
+        let __v_34: G = G::from_u64(0);
+        let __v_35: G = G::from_u64(0);
+        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 = { let __values: [G; 32] = [__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]; 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_42: G = G::from_u64(1);
+        let __v_43: G = G::from_u64(1);
+        let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __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 __ret: [G; OUT_365] = [__v_7, __v_8, __v_41, __v_44];
+        record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_453: usize = 5;
-const IN_453: usize = 5;
-const OUT_453: usize = 1;
-fn aiur_fn_453(
-  inp: [G; IN_453],
+const INPUT_SIZE_366: usize = 2;
+const IN_366: usize = 2;
+const OUT_366: usize = 3;
+fn aiur_fn_366(
+  inp: [G; IN_366],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_453], ExecError> {
+) -> Result<[G; OUT_366], 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 = (__v_3 - __v_4);
-    match __v_5.as_canonical_u64() {
-      0u64 => {
-        let __ret: [G; OUT_453] = [__v_0];
-        record.function_queries[453].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    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 };
+    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];
+    match __v_2.as_canonical_u64() {
+      1u64 => {
+        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 = { let __values: [G; 4] = [__v_9, __v_10, __v_11, __v_11]; 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_366] = [__v_7, __v_8, __v_12];
+        record.function_queries[366].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
+      0u64 => {
+        match __v_3.as_canonical_u64() {
+          _ => {
+            let __v_7: G = (__v_3 - __v_1);
+            match __v_7.as_canonical_u64() {
+              0u64 => {
+                let __v_8: G = G::from_u64(1);
+                let __ret: [G; OUT_366] = [__v_8, __v_4, __v_5];
+                record.function_queries[366].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                let __r_arr: [G; OUT_366] = { let __args: [G; IN_366] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[366].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_366] = unsafe { *(result.output.as_ptr() as *const [G; OUT_366]) }; __ret } else { aiur_fn_366(__args, record, io_buffer, __cu)? } };
+                let __v_8: G = __r_arr[0];
+                let __v_9: G = __r_arr[1];
+                let __v_10: G = __r_arr[2];
+                let __ret: [G; OUT_366] = [__v_8, __v_9, __v_10];
+                record.function_queries[366].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+            }
+          },
+        }
+      },
       _ => {
-        let __v_6: G = G::from_u64(8);
-        let __v_7: G = { let __values: [G; 4] = [__v_6, __v_1, __v_4, __v_2]; 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_8: G = G::from_u64(3);
-        let __v_9: G = G::from_u64(0);
-        let __v_10: G = { let __values: [G; 4] = [__v_8, __v_0, __v_7, __v_9]; 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_11: G = G::from_u64(1);
-        let __v_12: G = (__v_4 + __v_11);
-        let __r_arr: [G; OUT_453] = { let __args: [G; IN_453] = [__v_10, __v_1, __v_2, __v_3, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[453].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_453] = unsafe { *(result.output.as_ptr() as *const [G; OUT_453]) }; __ret } else { aiur_fn_453(__args, record, io_buffer, __cu)? } };
-        let __v_13: G = __r_arr[0];
-        let __ret: [G; OUT_453] = [__v_13];
-        record.function_queries[453].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_454: usize = 6;
-const IN_454: usize = 6;
-const OUT_454: usize = 2;
-fn aiur_fn_454(
-  inp: [G; IN_454],
+const INPUT_SIZE_367: usize = 9;
+const IN_367: usize = 9;
+const OUT_367: usize = 2;
+fn aiur_fn_367(
+  inp: [G; IN_367],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_454], ExecError> {
+) -> Result<[G; OUT_367], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -41137,600 +32729,561 @@ fn aiur_fn_454(
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
-    let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; 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: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].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];
-    match __v_6.as_canonical_u64() {
+    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_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: 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_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 = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; 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_454] = [__v_11, __v_15];
-        record.function_queries[454].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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 = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; 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_367] = [__v_14, __v_18];
+        record.function_queries[367].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        match __v_7.as_canonical_u64() {
-          _ => {
-            let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-            let __v_11: G = __r_arr[0];
-            let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr };
-            let __v_12: G = __loaded[0];
-            let __v_13: G = __loaded[1];
-            let __v_14: G = __loaded[2];
-            let __v_15: G = __loaded[3];
-            let __v_16: G = __loaded[4];
-            let __v_17: G = __loaded[5];
-            let __v_18: G = __loaded[6];
-            let __v_19: G = __loaded[7];
-            let __v_20: G = __loaded[8];
-            let __v_21: G = __loaded[9];
-            let __v_22: G = __loaded[10];
-            match __v_12.as_canonical_u64() {
-              6u64 => {
-                let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_4, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-                let __v_23: G = __r_arr[0];
-                let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_23.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr };
-                let __v_24: G = __loaded[0];
-                let __v_25: G = __loaded[1];
-                let __v_26: G = __loaded[2];
-                let __v_27: G = __loaded[3];
-                let __v_28: G = __loaded[4];
-                let __v_29: G = __loaded[5];
-                let __v_30: G = __loaded[6];
-                let __v_31: G = __loaded[7];
-                let __v_32: G = __loaded[8];
-                let __v_33: G = __loaded[9];
-                let __v_34: G = __loaded[10];
-                match __v_24.as_canonical_u64() {
-                  5u64 => {
-                    let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { 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_35: G = __r_arr[0];
-                    match __v_35.as_canonical_u64() {
-                      0u64 => {
-                        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 = { let __values: [G; 4] = [__v_37, __v_38, __v_39, __v_39]; 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_454] = [__v_36, __v_40];
-                        record.function_queries[454].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                        return Ok(__ret);
-                      },
-                      _ => {
-                        let __v_36: G = G::from_u64(0);
-                        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_29, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-                        let __v_37: G = __r_arr[0];
-                        let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_0, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[459].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_459] = unsafe { *(result.output.as_ptr() as *const [G; OUT_459]) }; __ret } else { aiur_fn_459(__args, record, io_buffer, __cu)? } };
-                        let __v_38: G = __r_arr[0];
-                        let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_38, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } };
-                        let __v_39: G = __r_arr[0];
-                        let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[189].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_189] = unsafe { *(result.output.as_ptr() as *const [G; OUT_189]) }; __ret } else { aiur_fn_189(__args, record, io_buffer, __cu)? } };
-                        let __v_40: G = __r_arr[0];
-                        let __v_41: G = __r_arr[1];
-                        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_40.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).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_42: G = __loaded[0];
-                        let __v_43: G = __loaded[1];
-                        let __v_44: G = __loaded[2];
-                        let __v_45: G = __loaded[3];
-                        match __v_42.as_canonical_u64() {
-                          2u64 => {
-                            let __v_46: G = (__v_43 - __v_15);
-                            match __v_46.as_canonical_u64() {
+        let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; 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: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].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];
+        let __v_18: G = __loaded[4];
+        match __v_14.as_canonical_u64() {
+          0u64 => {
+            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 = { let __values: [G; 4] = [__v_20, __v_21, __v_22, __v_22]; 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_367] = [__v_19, __v_23];
+            record.function_queries[367].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          1u64 => {
+            match __v_10.as_canonical_u64() {
+              _ => {
+                let __v_19: G = (__v_3 + __v_4);
+                let __v_20: G = (__v_19 + __v_5);
+                let __v_21: G = (__v_20 + __v_6);
+                let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_0, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } else { aiur_fn_368(__args, record, io_buffer, __cu)? } };
+                let __v_22: G = __r_arr[0];
+                let __v_23: G = __r_arr[1];
+                match __v_22.as_canonical_u64() {
+                  0u64 => {
+                    let __v_24: G = G::from_u64(0);
+                    let __v_25: G = G::from_u64(0);
+                    let __v_26: G = G::from_u64(0);
+                    let __v_27: G = G::from_u64(0);
+                    let __v_28: G = { let __values: [G; 4] = [__v_25, __v_26, __v_27, __v_27]; 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_367] = [__v_24, __v_28];
+                    record.function_queries[367].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
+                  },
+                  _ => {
+                    let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[258].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_258] = unsafe { *(result.output.as_ptr() as *const [G; OUT_258]) }; __ret } else { aiur_fn_258(__args, record, io_buffer, __cu)? } };
+                    let __v_24: G = __r_arr[0];
+                    let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; 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: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].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];
+                    match __v_25.as_canonical_u64() {
+                      5u64 => {
+                        let __v_37: G = G::from_u64(1);
+                        let __v_38: G = (__v_30 - __v_37);
+                        match __v_38.as_canonical_u64() {
+                          0u64 => {
+                            match __v_29.as_canonical_u64() {
                               0u64 => {
-                                let __v_47: G = G::from_u64(2);
-                                let __v_48: G = G::from_u64(0);
-                                let __v_49: G = { let __values: [G; 4] = [__v_47, __v_37, __v_44, __v_48]; 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_792] = { let __args: [G; IN_792] = [__v_41, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[792].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_792] = unsafe { *(result.output.as_ptr() as *const [G; OUT_792]) }; __ret } else { aiur_fn_792(__args, record, io_buffer, __cu)? } };
-                                let __v_50: G = __r_arr[0];
-                                let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[427].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_427] = unsafe { *(result.output.as_ptr() as *const [G; OUT_427]) }; __ret } else { aiur_fn_427(__args, record, io_buffer, __cu)? } };
-                                let __v_51: G = __r_arr[0];
-                                let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_51, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[459].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_459] = unsafe { *(result.output.as_ptr() as *const [G; OUT_459]) }; __ret } else { aiur_fn_459(__args, record, io_buffer, __cu)? } };
-                                let __v_52: G = __r_arr[0];
-                                let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_39, __v_52, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } };
-                                let __v_53: G = __r_arr[0];
-                                match __v_53.as_canonical_u64() {
+                                let __r_arr: [G; OUT_370] = { let __args: [G; IN_370] = [__v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[370].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_370] = unsafe { *(result.output.as_ptr() as *const [G; OUT_370]) }; __ret } else { aiur_fn_370(__args, record, io_buffer, __cu)? } };
+                                let __v_39: G = __r_arr[0];
+                                match __v_39.as_canonical_u64() {
                                   1u64 => {
-                                    let __v_54: G = G::from_u64(1);
-                                    let __ret: [G; OUT_454] = [__v_54, __v_51];
-                                    record.function_queries[454].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                    return Ok(__ret);
-                                  },
-                                  0u64 => {
-                                    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 = { let __values: [G; 4] = [__v_55, __v_56, __v_57, __v_57]; 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_454] = [__v_54, __v_58];
-                                    record.function_queries[454].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                    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 = { let __values: [G; 4] = [__v_41, __v_42, __v_43, __v_43]; 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_367] = [__v_40, __v_44];
+                                    record.function_queries[367].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                     return Ok(__ret);
                                   },
                                   _ => {
-                                    return Err(ExecError::MatchNoCase(__v_53.as_canonical_u64()));
+                                    let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_2, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } };
+                                    let __v_40: G = __r_arr[0];
+                                    let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_40, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[434].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_434] = unsafe { *(result.output.as_ptr() as *const [G; OUT_434]) }; __ret } else { aiur_fn_434(__args, record, io_buffer, __cu)? } };
+                                    let __v_41: G = __r_arr[0];
+                                    let __r_arr: [G; OUT_416] = { let __args: [G; IN_416] = [__v_41, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[416].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_416] = unsafe { *(result.output.as_ptr() as *const [G; OUT_416]) }; __ret } else { aiur_fn_416(__args, record, io_buffer, __cu)? } };
+                                    let __v_42: G = __r_arr[0];
+                                    match __v_42.as_canonical_u64() {
+                                      1u64 => {
+                                        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 = { let __values: [G; 4] = [__v_44, __v_45, __v_46, __v_46]; 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_367] = [__v_43, __v_47];
+                                        record.function_queries[367].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                        return Ok(__ret);
+                                      },
+                                      _ => {
+                                        let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_12, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } else { aiur_fn_307(__args, record, io_buffer, __cu)? } };
+                                        let __v_43: G = __r_arr[0];
+                                        let __v_44: G = (__v_3 + __v_4);
+                                        let __v_45: G = (__v_44 + __v_5);
+                                        let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_2, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } else { aiur_fn_721(__args, record, io_buffer, __cu)? } };
+                                        let __v_46: G = __r_arr[0];
+                                        let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_43, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } };
+                                        let __v_47: G = __r_arr[0];
+                                        let __v_48: G = G::from_u64(0);
+                                        let __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__v_47, __v_23, __v_40, __v_11, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[369].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_369] = unsafe { *(result.output.as_ptr() as *const [G; OUT_369]) }; __ret } else { aiur_fn_369(__args, record, io_buffer, __cu)? } };
+                                        let __v_49: G = __r_arr[0];
+                                        let __v_50: G = G::from_u64(1);
+                                        let __v_51: G = (__v_21 + __v_50);
+                                        let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_2, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } };
+                                        let __v_52: G = __r_arr[0];
+                                        let __v_53: G = G::from_u64(1);
+                                        let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_49, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } };
+                                        let __v_54: G = __r_arr[0];
+                                        let __ret: [G; OUT_367] = [__v_53, __v_54];
+                                        record.function_queries[367].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                        return Ok(__ret);
+                                      },
+                                    }
                                   },
                                 }
                               },
                               _ => {
-                                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 = G::from_u64(0);
-                                let __v_51: G = { let __values: [G; 4] = [__v_48, __v_49, __v_50, __v_50]; 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_454] = [__v_47, __v_51];
-                                record.function_queries[454].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                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 = { let __values: [G; 4] = [__v_40, __v_41, __v_42, __v_42]; 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_367] = [__v_39, __v_43];
+                                record.function_queries[367].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
                           },
                           _ => {
-                            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; 4] = [__v_47, __v_48, __v_49, __v_49]; 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_454] = [__v_46, __v_50];
-                            record.function_queries[454].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            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 = { let __values: [G; 4] = [__v_40, __v_41, __v_42, __v_42]; 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_367] = [__v_39, __v_43];
+                            record.function_queries[367].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                         }
                       },
+                      _ => {
+                        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 = { let __values: [G; 4] = [__v_38, __v_39, __v_40, __v_40]; 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_367] = [__v_37, __v_41];
+                        record.function_queries[367].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        return Ok(__ret);
+                      },
                     }
                   },
-                  _ => {
-                    return Err(ExecError::MatchNoCase(__v_24.as_canonical_u64()));
-                  },
                 }
               },
-              _ => {
-                return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64()));
-              },
             }
           },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64()));
+          },
         }
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64()));
+        return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_455: usize = 2;
-const IN_455: usize = 2;
-const OUT_455: usize = 1;
-fn aiur_fn_455(
-  inp: [G; IN_455],
+const INPUT_SIZE_368: usize = 2;
+const IN_368: usize = 2;
+const OUT_368: usize = 2;
+fn aiur_fn_368(
+  inp: [G; IN_368],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_455], ExecError> {
+) -> Result<[G; OUT_368], 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 __v_6: G = G::from_u64(0);
-        let __v_7: G = G::from_u64(0);
-        let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __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_455] = [__v_8];
-        record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
+    match __v_1.as_canonical_u64() {
       0u64 => {
-        match __v_1.as_canonical_u64() {
-          0u64 => {
-            let __ret: [G; OUT_455] = [__v_3];
-            record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
+        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() {
+          5u64 => {
+            let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[106].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_106] = unsafe { *(result.output.as_ptr() as *const [G; OUT_106]) }; __ret } else { aiur_fn_106(__args, record, io_buffer, __cu)? } };
+            let __v_6: G = __r_arr[0];
+            let __v_7: G = __r_arr[1];
+            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; 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: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].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];
+            match __v_8.as_canonical_u64() {
+              2u64 => {
+                let __v_12: G = G::from_u64(1);
+                let __ret: [G; OUT_368] = [__v_12, __v_9];
+                record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                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 = 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 __v_24: G = G::from_u64(0);
+                let __v_25: G = G::from_u64(0);
+                let __v_26: G = G::from_u64(0);
+                let __v_27: G = G::from_u64(0);
+                let __v_28: G = G::from_u64(0);
+                let __v_29: G = G::from_u64(0);
+                let __v_30: G = G::from_u64(0);
+                let __v_31: G = G::from_u64(0);
+                let __v_32: G = G::from_u64(0);
+                let __v_33: G = G::from_u64(0);
+                let __v_34: G = G::from_u64(0);
+                let __v_35: G = G::from_u64(0);
+                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; 32] = [__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]; 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_368] = [__v_12, __v_45];
+                record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+            }
           },
           _ => {
-            let __v_5: G = G::from_u64(1);
-            let __v_6: G = (__v_1 - __v_5);
-            let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[455].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_455] = unsafe { *(result.output.as_ptr() as *const [G; OUT_455]) }; __ret } else { aiur_fn_455(__args, record, io_buffer, __cu)? } };
-            let __v_7: G = __r_arr[0];
-            let __ret: [G; OUT_455] = [__v_7];
-            record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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 __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 = 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 __v_24: G = G::from_u64(0);
+            let __v_25: G = G::from_u64(0);
+            let __v_26: G = G::from_u64(0);
+            let __v_27: G = G::from_u64(0);
+            let __v_28: G = G::from_u64(0);
+            let __v_29: G = G::from_u64(0);
+            let __v_30: G = G::from_u64(0);
+            let __v_31: G = G::from_u64(0);
+            let __v_32: G = G::from_u64(0);
+            let __v_33: G = G::from_u64(0);
+            let __v_34: G = G::from_u64(0);
+            let __v_35: G = G::from_u64(0);
+            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 = { let __values: [G; 32] = [__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, __v_37, __v_38]; 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_368] = [__v_6, __v_39];
+            record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_456: usize = 1;
-const IN_456: usize = 1;
-const OUT_456: usize = 2;
-fn aiur_fn_456(
-  inp: [G; IN_456],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_456], 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(1);
-        let __ret: [G; OUT_456] = [__v_5, __v_2];
-        record.function_queries[456].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        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 = { 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_456] = [__v_5, __v_8];
-        record.function_queries[456].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_457: usize = 1;
-const IN_457: usize = 1;
-const OUT_457: usize = 3;
-fn aiur_fn_457(
-  inp: [G; IN_457],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_457], 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() {
-      5u64 => {
-        let __v_5: G = G::from_u64(1);
-        let __ret: [G; OUT_457] = [__v_5, __v_2, __v_3];
-        record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        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; 4] = [__v_6, __v_7, __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 __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; 4] = [__v_10, __v_11, __v_12, __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_457] = [__v_5, __v_9, __v_13];
-        record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_458: usize = 2;
-const IN_458: usize = 2;
-const OUT_458: usize = 1;
-fn aiur_fn_458(
-  inp: [G; IN_458],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_458], 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 __v_6: G = G::from_u64(0);
-        let __v_7: G = G::from_u64(0);
-        let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __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_458] = [__v_8];
-        record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      0u64 => {
-        match __v_1.as_canonical_u64() {
-          0u64 => {
-            let __v_5: G = G::from_u64(1);
-            let __v_6: G = G::from_u64(0);
-            let __r_arr: [G; OUT_413] = { let __args: [G; IN_413] = [__v_3, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[413].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_413] = unsafe { *(result.output.as_ptr() as *const [G; OUT_413]) }; __ret } else { aiur_fn_413(__args, record, io_buffer, __cu)? } };
-            let __v_7: G = __r_arr[0];
-            let __ret: [G; OUT_458] = [__v_7];
-            record.function_queries[458].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() {
+          5u64 => {
+            let __v_6: G = G::from_u64(1);
+            let __v_7: G = (__v_1 - __v_6);
+            let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } else { aiur_fn_368(__args, record, io_buffer, __cu)? } };
+            let __v_8: G = __r_arr[0];
+            let __v_9: G = __r_arr[1];
+            let __ret: [G; OUT_368] = [__v_8, __v_9];
+            record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __v_5: G = G::from_u64(1);
-            let __v_6: G = (__v_1 - __v_5);
-            let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[458].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_458] = unsafe { *(result.output.as_ptr() as *const [G; OUT_458]) }; __ret } else { aiur_fn_458(__args, record, io_buffer, __cu)? } };
-            let __v_7: G = __r_arr[0];
-            let __v_8: 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 __r_arr: [G; OUT_413] = { let __args: [G; IN_413] = [__v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[413].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_413] = unsafe { *(result.output.as_ptr() as *const [G; OUT_413]) }; __ret } else { aiur_fn_413(__args, record, io_buffer, __cu)? } };
-            let __v_10: G = __r_arr[0];
-            let __ret: [G; OUT_458] = [__v_10];
-            record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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 = 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 __v_24: G = G::from_u64(0);
+            let __v_25: G = G::from_u64(0);
+            let __v_26: G = G::from_u64(0);
+            let __v_27: G = G::from_u64(0);
+            let __v_28: G = G::from_u64(0);
+            let __v_29: G = G::from_u64(0);
+            let __v_30: G = G::from_u64(0);
+            let __v_31: G = G::from_u64(0);
+            let __v_32: G = G::from_u64(0);
+            let __v_33: G = G::from_u64(0);
+            let __v_34: G = G::from_u64(0);
+            let __v_35: G = G::from_u64(0);
+            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 = { let __values: [G; 32] = [__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, __v_37, __v_38]; 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_368] = [__v_6, __v_39];
+            record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
     }
   })
 }
 
-const INPUT_SIZE_459: usize = 4;
-const IN_459: usize = 4;
-const OUT_459: usize = 1;
-fn aiur_fn_459(
-  inp: [G; IN_459],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_459], 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_400] = { let __args: [G; IN_400] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } };
-    let __v_4: G = __r_arr[0];
-    let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[412].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_412] = unsafe { *(result.output.as_ptr() as *const [G; OUT_412]) }; __ret } else { aiur_fn_412(__args, record, io_buffer, __cu)? } };
-    let __v_5: G = __r_arr[0];
-    let __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__v_0, __v_5, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[460].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_460] = unsafe { *(result.output.as_ptr() as *const [G; OUT_460]) }; __ret } else { aiur_fn_460(__args, record, io_buffer, __cu)? } };
-    let __v_6: G = __r_arr[0];
-    let __ret: [G; OUT_459] = [__v_6];
-    record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_460: usize = 4;
-const IN_460: usize = 4;
-const OUT_460: usize = 1;
-fn aiur_fn_460(
-  inp: [G; IN_460],
+const INPUT_SIZE_369: usize = 5;
+const IN_369: usize = 5;
+const OUT_369: usize = 1;
+fn aiur_fn_369(
+  inp: [G; IN_369],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_460], ExecError> {
+) -> Result<[G; OUT_369], 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; 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_4: G = __loaded[0];
-    let __v_5: G = __loaded[1];
-    let __v_6: G = __loaded[2];
-    let __v_7: G = __loaded[3];
-    match __v_4.as_canonical_u64() {
+    let __v_4: G = inp[4];
+    let __v_5: G = (__v_3 - __v_4);
+    match __v_5.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[458].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_458] = unsafe { *(result.output.as_ptr() as *const [G; OUT_458]) }; __ret } else { aiur_fn_458(__args, record, io_buffer, __cu)? } };
-        let __v_8: G = __r_arr[0];
-        let __ret: [G; OUT_460] = [__v_8];
-        record.function_queries[460].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      1u64 => {
-        let __v_8: G = G::from_u64(1);
-        let __v_9: G = G::from_u64(1);
-        let __v_10: G = G::from_u64(0);
-        let __v_11: G = { let __values: [G; 3] = [__v_9, __v_5, __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_225] = { let __args: [G; IN_225] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[225].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_225] = unsafe { *(result.output.as_ptr() as *const [G; OUT_225]) }; __ret } else { aiur_fn_225(__args, record, io_buffer, __cu)? } };
-        let __v_12: G = __r_arr[0];
-        let __v_13: G = G::from_u64(0);
-        let __v_14: G = { let __values: [G; 4] = [__v_8, __v_12, __v_13, __v_13]; 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_460] = [__v_14];
-        record.function_queries[460].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      2u64 => {
-        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-        let __v_8: G = __r_arr[0];
-        let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].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 __v_17: G = __loaded[8];
-        let __v_18: G = __loaded[9];
-        let __v_19: G = __loaded[10];
-        let __r_arr: [G; OUT_471] = { let __args: [G; IN_471] = [__v_9, __v_10, __v_11, __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[471].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_471] = unsafe { *(result.output.as_ptr() as *const [G; OUT_471]) }; __ret } else { aiur_fn_471(__args, record, io_buffer, __cu)? } };
-        let __v_20: G = __r_arr[0];
-        let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { 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_21: G = __r_arr[0];
-        let __r_arr: [G; OUT_470] = { let __args: [G; IN_470] = [__v_9, __v_10, __v_11, __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[470].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_470] = unsafe { *(result.output.as_ptr() as *const [G; OUT_470]) }; __ret } else { aiur_fn_470(__args, record, io_buffer, __cu)? } };
-        let __v_22: G = __r_arr[0];
-        if (__v_21 != __v_20) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_21.as_canonical_u64(), rhs: __v_20.as_canonical_u64() });
-        }
-        let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_22, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } };
-        let __v_23: G = __r_arr[0];
-        let __ret: [G; OUT_460] = [__v_23];
-        record.function_queries[460].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      3u64 => {
-        let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[189].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_189] = unsafe { *(result.output.as_ptr() as *const [G; OUT_189]) }; __ret } else { aiur_fn_189(__args, record, io_buffer, __cu)? } };
-        let __v_8: G = __r_arr[0];
-        let __v_9: G = __r_arr[1];
-        let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_8, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[459].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_459] = unsafe { *(result.output.as_ptr() as *const [G; OUT_459]) }; __ret } else { aiur_fn_459(__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_464] = { let __args: [G; IN_464] = [__v_10, __v_9, __v_13, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[464].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_464] = unsafe { *(result.output.as_ptr() as *const [G; OUT_464]) }; __ret } else { aiur_fn_464(__args, record, io_buffer, __cu)? } };
-        let __v_14: G = __r_arr[0];
-        let __ret: [G; OUT_460] = [__v_14];
-        record.function_queries[460].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      4u64 => {
-        let __r_arr: [G; OUT_465] = { let __args: [G; IN_465] = [__v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[465].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_465] = unsafe { *(result.output.as_ptr() as *const [G; OUT_465]) }; __ret } else { aiur_fn_465(__args, record, io_buffer, __cu)? } };
-        let __v_8: G = __r_arr[0];
-        let __v_9: G = G::from_u64(0);
-        let __v_10: G = { let __values: [G; 3] = [__v_9, __v_5, __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_459] = { let __args: [G; IN_459] = [__v_6, __v_10, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[459].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_459] = unsafe { *(result.output.as_ptr() as *const [G; OUT_459]) }; __ret } else { aiur_fn_459(__args, record, io_buffer, __cu)? } };
-        let __v_11: G = __r_arr[0];
-        let __v_12: G = G::from_u64(5);
-        let __v_13: G = G::from_u64(0);
-        let __v_14: G = { let __values: [G; 4] = [__v_12, __v_5, __v_11, __v_13]; 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_460] = [__v_14];
-        record.function_queries[460].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_369] = [__v_0];
+        record.function_queries[369].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      5u64 => {
-        let __r_arr: [G; OUT_465] = { let __args: [G; IN_465] = [__v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[465].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_465] = unsafe { *(result.output.as_ptr() as *const [G; OUT_465]) }; __ret } else { aiur_fn_465(__args, record, io_buffer, __cu)? } };
-        let __v_8: G = __r_arr[0];
+      _ => {
+        let __v_6: G = G::from_u64(8);
+        let __v_7: G = { let __values: [G; 4] = [__v_6, __v_1, __v_4, __v_2]; 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_8: G = G::from_u64(3);
         let __v_9: G = G::from_u64(0);
-        let __v_10: G = { let __values: [G; 3] = [__v_9, __v_5, __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_465] = { let __args: [G; IN_465] = [__v_6, __v_10, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[465].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_465] = unsafe { *(result.output.as_ptr() as *const [G; OUT_465]) }; __ret } else { aiur_fn_465(__args, record, io_buffer, __cu)? } };
-        let __v_11: G = __r_arr[0];
-        let __v_12: G = G::from_u64(1);
-        let __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[224].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_224] = unsafe { *(result.output.as_ptr() as *const [G; OUT_224]) }; __ret } else { aiur_fn_224(__args, record, io_buffer, __cu)? } };
+        let __v_10: G = { let __values: [G; 4] = [__v_8, __v_0, __v_7, __v_9]; 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_11: G = G::from_u64(1);
+        let __v_12: G = (__v_4 + __v_11);
+        let __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__v_10, __v_1, __v_2, __v_3, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[369].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_369] = unsafe { *(result.output.as_ptr() as *const [G; OUT_369]) }; __ret } else { aiur_fn_369(__args, record, io_buffer, __cu)? } };
         let __v_13: G = __r_arr[0];
-        let __v_14: G = G::from_u64(0);
-        let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; 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_460] = [__v_15];
-        record.function_queries[460].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      6u64 => {
-        let __r_arr: [G; OUT_461] = { let __args: [G; IN_461] = [__v_5, __v_6, __v_7, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[461].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_461] = unsafe { *(result.output.as_ptr() as *const [G; OUT_461]) }; __ret } else { aiur_fn_461(__args, record, io_buffer, __cu)? } };
-        let __v_8: G = __r_arr[0];
-        let __ret: [G; OUT_460] = [__v_8];
-        record.function_queries[460].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      7u64 => {
-        let __r_arr: [G; OUT_462] = { let __args: [G; IN_462] = [__v_5, __v_6, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[462].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_462] = unsafe { *(result.output.as_ptr() as *const [G; OUT_462]) }; __ret } else { aiur_fn_462(__args, record, io_buffer, __cu)? } };
-        let __v_8: G = __r_arr[0];
-        let __ret: [G; OUT_460] = [__v_8];
-        record.function_queries[460].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      8u64 => {
-        let __r_arr: [G; OUT_463] = { let __args: [G; IN_463] = [__v_5, __v_6, __v_7, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[463].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_463] = unsafe { *(result.output.as_ptr() as *const [G; OUT_463]) }; __ret } else { aiur_fn_463(__args, record, io_buffer, __cu)? } };
-        let __v_8: G = __r_arr[0];
-        let __ret: [G; OUT_460] = [__v_8];
-        record.function_queries[460].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_369] = [__v_13];
+        record.function_queries[369].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
-      },
     }
   })
 }
 
-const INPUT_SIZE_461: usize = 6;
-const IN_461: usize = 6;
-const OUT_461: usize = 1;
-fn aiur_fn_461(
-  inp: [G; IN_461],
+const INPUT_SIZE_370: usize = 1;
+const IN_370: usize = 1;
+const OUT_370: usize = 1;
+fn aiur_fn_370(
+  inp: [G; IN_370],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_461], ExecError> {
+) -> Result<[G; OUT_370], 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_465] = { let __args: [G; IN_465] = [__v_0, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[465].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_465] = unsafe { *(result.output.as_ptr() as *const [G; OUT_465]) }; __ret } else { aiur_fn_465(__args, record, io_buffer, __cu)? } };
-    let __v_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_466] = { let __args: [G; IN_466] = [__v_1, __v_0, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[466].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_466] = unsafe { *(result.output.as_ptr() as *const [G; OUT_466]) }; __ret } else { aiur_fn_466(__args, record, io_buffer, __cu)? } };
-    let __v_7: G = G::from_u64(0);
-    let __r_arr: [G; OUT_419] = { let __args: [G; IN_419] = [__v_2, __v_1, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[419].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_419] = unsafe { *(result.output.as_ptr() as *const [G; OUT_419]) }; __ret } else { aiur_fn_419(__args, record, io_buffer, __cu)? } };
-    let __v_8: G = __r_arr[0];
-    let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_8, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[459].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_459] = unsafe { *(result.output.as_ptr() as *const [G; OUT_459]) }; __ret } else { aiur_fn_459(__args, record, io_buffer, __cu)? } };
-    let __v_9: G = __r_arr[0];
-    let __ret: [G; OUT_461] = [__v_9];
-    record.function_queries[461].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
+    let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[258].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_258] = unsafe { *(result.output.as_ptr() as *const [G; OUT_258]) }; __ret } else { aiur_fn_258(__args, record, io_buffer, __cu)? } };
+    let __v_1: G = __r_arr[0];
+    let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; 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: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].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];
+    let __v_12: G = __loaded[10];
+    let __v_13: G = __loaded[11];
+    match __v_2.as_canonical_u64() {
+      5u64 => {
+        let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[371].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_371] = unsafe { *(result.output.as_ptr() as *const [G; OUT_371]) }; __ret } else { aiur_fn_371(__args, record, io_buffer, __cu)? } };
+        let __v_14: G = __r_arr[0];
+        let __v_15: G = G::from_u64(0);
+        let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_9, __v_10, __v_7, __v_5, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[372].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_372] = unsafe { *(result.output.as_ptr() as *const [G; OUT_372]) }; __ret } else { aiur_fn_372(__args, record, io_buffer, __cu)? } };
+        let __v_16: G = __r_arr[0];
+        let __ret: [G; OUT_370] = [__v_16];
+        record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __v_14: G = G::from_u64(1);
+        let __ret: [G; OUT_370] = [__v_14];
+        record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+    }
   })
 }
 
-const INPUT_SIZE_462: usize = 3;
-const IN_462: usize = 3;
-const OUT_462: usize = 1;
-fn aiur_fn_462(
-  inp: [G; IN_462],
+const INPUT_SIZE_371: usize = 2;
+const IN_371: usize = 2;
+const OUT_371: usize = 1;
+fn aiur_fn_371(
+  inp: [G; IN_371],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_462], ExecError> {
+) -> Result<[G; OUT_371], 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_478] = { let __args: [G; IN_478] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[478].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_478] = unsafe { *(result.output.as_ptr() as *const [G; OUT_478]) }; __ret } else { aiur_fn_478(__args, record, io_buffer, __cu)? } };
-        let __v_3: G = __r_arr[0];
-        let __ret: [G; OUT_462] = [__v_3];
-        record.function_queries[462].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      1u64 => {
-        let __r_arr: [G; OUT_479] = { let __args: [G; IN_479] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[479].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_479] = unsafe { *(result.output.as_ptr() as *const [G; OUT_479]) }; __ret } else { aiur_fn_479(__args, record, io_buffer, __cu)? } };
-        let __v_3: G = __r_arr[0];
-        let __ret: [G; OUT_462] = [__v_3];
-        record.function_queries[462].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
+    let __v_1: G = inp[1];
+    let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } else { aiur_fn_255(__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 = __r_arr[10];
+    let __v_13: G = __r_arr[11];
+    let __v_14: G = __r_arr[12];
+    let __v_15: G = __r_arr[13];
+    let __v_16: G = __r_arr[14];
+    let __v_17: G = __r_arr[15];
+    let __v_18: G = __r_arr[16];
+    let __v_19: G = __r_arr[17];
+    let __v_20: G = __r_arr[18];
+    let __v_21: G = __r_arr[19];
+    let __v_22: G = __r_arr[20];
+    let __v_23: G = __r_arr[21];
+    let __v_24: G = __r_arr[22];
+    let __v_25: G = __r_arr[23];
+    let __v_26: G = __r_arr[24];
+    let __v_27: G = __r_arr[25];
+    let __v_28: G = __r_arr[26];
+    let __v_29: G = __r_arr[27];
+    let __v_30: G = __r_arr[28];
+    let __v_31: G = __r_arr[29];
+    let __v_32: G = __r_arr[30];
+    let __v_33: G = __r_arr[31];
+    let __v_34: G = __r_arr[32];
+    let __v_35: G = __r_arr[33];
+    let __v_36: G = __r_arr[34];
+    let __v_37: G = __r_arr[35];
+    let __v_38: G = __r_arr[36];
+    let __v_39: G = __r_arr[37];
+    let __v_40: G = __r_arr[38];
+    let __v_41: G = __r_arr[39];
+    let __v_42: G = __r_arr[40];
+    let __v_43: G = __r_arr[41];
+    let __v_44: G = __r_arr[42];
+    let __v_45: G = __r_arr[43];
+    let __v_46: G = __r_arr[44];
+    let __v_47: G = __r_arr[45];
+    let __v_48: G = __r_arr[46];
+    let __v_49: G = __r_arr[47];
+    match __v_2.as_canonical_u64() {
       _ => {
-        return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64()));
+        match __v_2.as_canonical_u64() {
+          8u64 => {
+            let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = unsafe { *(result.output.as_ptr() as *const [G; OUT_267]) }; __ret } else { aiur_fn_267(__args, record, io_buffer, __cu)? } };
+            let __v_50: G = __r_arr[0];
+            let __ret: [G; OUT_371] = [__v_50];
+            record.function_queries[371].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            let __v_50: G = G::from_u64(0);
+            let __v_51: G = G::from_u64(1);
+            let __v_52: G = G::from_u64(1);
+            let __v_53: G = { let __values: [G; 3] = [__v_51, __v_52, __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_50, __v_0, __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 __ret: [G; OUT_371] = [__v_54];
+            record.function_queries[371].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+        }
       },
     }
   })
 }
 
-const INPUT_SIZE_463: usize = 6;
-const IN_463: usize = 6;
-const OUT_463: usize = 1;
-fn aiur_fn_463(
-  inp: [G; IN_463],
+const INPUT_SIZE_372: usize = 6;
+const IN_372: usize = 6;
+const OUT_372: usize = 1;
+fn aiur_fn_372(
+  inp: [G; IN_372],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_463], ExecError> {
+) -> Result<[G; OUT_372], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -41738,884 +33291,840 @@ fn aiur_fn_463(
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
-    let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[459].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_459] = unsafe { *(result.output.as_ptr() as *const [G; OUT_459]) }; __ret } else { aiur_fn_459(__args, record, io_buffer, __cu)? } };
-    let __v_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_6, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } };
-    let __v_7: G = __r_arr[0];
-    let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[189].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_189] = unsafe { *(result.output.as_ptr() as *const [G; OUT_189]) }; __ret } else { aiur_fn_189(__args, record, io_buffer, __cu)? } };
-    let __v_8: G = __r_arr[0];
-    let __v_9: G = __r_arr[1];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).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_10: G = __loaded[0];
-    let __v_11: G = __loaded[1];
-    let __v_12: G = __loaded[2];
-    let __v_13: G = __loaded[3];
-    match __v_10.as_canonical_u64() {
-      2u64 => {
-        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_4, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-        let __v_14: G = __r_arr[0];
-        let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr };
-        let __v_15: G = __loaded[0];
-        let __v_16: G = __loaded[1];
-        let __v_17: G = __loaded[2];
-        let __v_18: G = __loaded[3];
-        let __v_19: G = __loaded[4];
-        let __v_20: G = __loaded[5];
-        let __v_21: G = __loaded[6];
-        let __v_22: G = __loaded[7];
-        let __v_23: G = __loaded[8];
-        let __v_24: G = __loaded[9];
-        let __v_25: G = __loaded[10];
-        if (__v_11 != __v_0) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_0.as_canonical_u64() });
-        }
-        match __v_15.as_canonical_u64() {
-          5u64 => {
-            let __v_26: G = (__v_18 + __v_19);
-            let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_17, __v_12, __v_26, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[476].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_476] = unsafe { *(result.output.as_ptr() as *const [G; OUT_476]) }; __ret } else { aiur_fn_476(__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_778] = { let __args: [G; IN_778] = [__v_20, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-            let __v_29: G = __r_arr[0];
-            let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_4, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-            let __v_30: G = __r_arr[0];
-            let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr };
-            let __v_31: G = __loaded[0];
-            let __v_32: G = __loaded[1];
-            let __v_33: G = __loaded[2];
-            let __v_34: G = __loaded[3];
-            let __v_35: G = __loaded[4];
-            let __v_36: G = __loaded[5];
-            let __v_37: G = __loaded[6];
-            let __v_38: G = __loaded[7];
-            let __v_39: G = __loaded[8];
-            let __v_40: G = __loaded[9];
-            let __v_41: G = __loaded[10];
-            let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { 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_42: G = __r_arr[0];
-            let __v_43: G = G::from_u64(1);
-            if (__v_42 != __v_43) {
-              return Err(ExecError::AssertEqMismatch { lhs: __v_42.as_canonical_u64(), rhs: __v_43.as_canonical_u64() });
-            }
-            match __v_31.as_canonical_u64() {
-              6u64 => {
-                let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_33, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } };
-                let __v_44: G = __r_arr[0];
-                let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_44, __v_9, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[472].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_472] = unsafe { *(result.output.as_ptr() as *const [G; OUT_472]) }; __ret } else { aiur_fn_472(__args, record, io_buffer, __cu)? } };
-                let __v_45: G = __r_arr[0];
-                let __v_46: G = G::from_u64(0);
-                let __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__v_45, __v_1, __v_46, __v_0, __v_2, __v_27, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[473].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_473] = unsafe { *(result.output.as_ptr() as *const [G; OUT_473]) }; __ret } else { aiur_fn_473(__args, record, io_buffer, __cu)? } };
-                let __v_47: G = __r_arr[0];
-                let __ret: [G; OUT_463] = [__v_47];
-                record.function_queries[463].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __v_6: G = (__v_2 - __v_5);
+    match __v_6.as_canonical_u64() {
+      0u64 => {
+        let __v_7: G = G::from_u64(0);
+        let __ret: [G; OUT_372] = [__v_7];
+        record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_0, __v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[261].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_261] = unsafe { *(result.output.as_ptr() as *const [G; OUT_261]) }; __ret } else { aiur_fn_261(__args, record, io_buffer, __cu)? } };
+        let __v_7: G = __r_arr[0];
+        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; 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: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].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];
+        let __v_18: G = __loaded[10];
+        let __v_19: G = __loaded[11];
+        match __v_8.as_canonical_u64() {
+          6u64 => {
+            let __r_arr: [G; OUT_373] = { let __args: [G; IN_373] = [__v_10, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[373].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_373] = unsafe { *(result.output.as_ptr() as *const [G; OUT_373]) }; __ret } else { aiur_fn_373(__args, record, io_buffer, __cu)? } };
+            let __v_20: G = __r_arr[0];
+            let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_20, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[374].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_374] = unsafe { *(result.output.as_ptr() as *const [G; OUT_374]) }; __ret } else { aiur_fn_374(__args, record, io_buffer, __cu)? } };
+            let __v_21: G = __r_arr[0];
+            match __v_21.as_canonical_u64() {
+              1u64 => {
+                let __v_22: G = G::from_u64(1);
+                let __ret: [G; OUT_372] = [__v_22];
+                record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                return Err(ExecError::MatchNoCase(__v_31.as_canonical_u64()));
+                let __v_22: G = G::from_u64(1);
+                let __v_23: G = (__v_5 + __v_22);
+                let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[372].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_372] = unsafe { *(result.output.as_ptr() as *const [G; OUT_372]) }; __ret } else { aiur_fn_372(__args, record, io_buffer, __cu)? } };
+                let __v_24: G = __r_arr[0];
+                let __ret: [G; OUT_372] = [__v_24];
+                record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
               },
             }
           },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_15.as_canonical_u64()));
+            let __v_20: G = G::from_u64(1);
+            let __ret: [G; OUT_372] = [__v_20];
+            record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64()));
-      },
     }
   })
 }
 
-const INPUT_SIZE_464: usize = 6;
-const IN_464: usize = 6;
-const OUT_464: usize = 1;
-fn aiur_fn_464(
-  inp: [G; IN_464],
+const INPUT_SIZE_373: usize = 2;
+const IN_373: usize = 2;
+const OUT_373: usize = 1;
+fn aiur_fn_373(
+  inp: [G; IN_373],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_464], ExecError> {
+) -> Result<[G; OUT_373], 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_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() {
-      1u64 => {
-        let __v_9: G = G::from_u64(0);
-        let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_0, __v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[423].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_423] = unsafe { *(result.output.as_ptr() as *const [G; OUT_423]) }; __ret } else { aiur_fn_423(__args, record, io_buffer, __cu)? } };
-        let __v_10: G = __r_arr[0];
-        let __ret: [G; OUT_464] = [__v_10];
-        record.function_queries[464].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    match __v_1.as_canonical_u64() {
+      0u64 => {
+        let __ret: [G; OUT_373] = [__v_0];
+        record.function_queries[373].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_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_9: G = __loaded[0];
-        let __v_10: G = __loaded[1];
-        let __v_11: G = __loaded[2];
-        let __v_12: G = __loaded[3];
-        match __v_9.as_canonical_u64() {
+        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() {
           5u64 => {
-            let __v_13: G = G::from_u64(0);
-            let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_10, __v_2, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[423].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_423] = unsafe { *(result.output.as_ptr() as *const [G; OUT_423]) }; __ret } else { aiur_fn_423(__args, record, io_buffer, __cu)? } };
-            let __v_14: G = __r_arr[0];
-            let __r_arr: [G; OUT_466] = { let __args: [G; IN_466] = [__v_7, __v_14, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[466].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_466] = unsafe { *(result.output.as_ptr() as *const [G; OUT_466]) }; __ret } else { aiur_fn_466(__args, record, io_buffer, __cu)? } };
-            let __v_15: G = G::from_u64(0);
-            let __v_16: G = { let __values: [G; 3] = [__v_15, __v_7, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_464] = { let __args: [G; IN_464] = [__v_11, __v_8, __v_16, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[464].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_464] = unsafe { *(result.output.as_ptr() as *const [G; OUT_464]) }; __ret } else { aiur_fn_464(__args, record, io_buffer, __cu)? } };
-            let __v_17: G = __r_arr[0];
-            let __ret: [G; OUT_464] = [__v_17];
-            record.function_queries[464].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __v_6: G = G::from_u64(1);
+            let __v_7: G = (__v_1 - __v_6);
+            let __r_arr: [G; OUT_373] = { let __args: [G; IN_373] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[373].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_373] = unsafe { *(result.output.as_ptr() as *const [G; OUT_373]) }; __ret } else { aiur_fn_373(__args, record, io_buffer, __cu)? } };
+            let __v_8: G = __r_arr[0];
+            let __ret: [G; OUT_373] = [__v_8];
+            record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __v_13: G = G::from_u64(0);
-            let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_0, __v_2, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[423].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_423] = unsafe { *(result.output.as_ptr() as *const [G; OUT_423]) }; __ret } else { aiur_fn_423(__args, record, io_buffer, __cu)? } };
-            let __v_14: G = __r_arr[0];
-            let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_14, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } };
-            let __v_15: G = __r_arr[0];
-            let __r_arr: [G; OUT_457] = { let __args: [G; IN_457] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[457].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_457] = unsafe { *(result.output.as_ptr() as *const [G; OUT_457]) }; __ret } else { aiur_fn_457(__args, record, io_buffer, __cu)? } };
-            let __v_16: G = __r_arr[0];
-            let __v_17: G = __r_arr[1];
-            let __v_18: G = __r_arr[2];
-            let __r_arr: [G; OUT_466] = { let __args: [G; IN_466] = [__v_7, __v_17, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[466].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_466] = unsafe { *(result.output.as_ptr() as *const [G; OUT_466]) }; __ret } else { aiur_fn_466(__args, record, io_buffer, __cu)? } };
-            let __v_19: G = G::from_u64(0);
-            let __v_20: G = G::from_u64(1);
-            let __v_21: G = G::from_u64(1);
-            let __v_22: G = { let __values: [G; 3] = [__v_20, __v_21, __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_19, __v_7, __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 = G::from_u64(1);
-            if (__v_16 != __v_24) {
-              return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_24.as_canonical_u64() });
-            }
-            let __r_arr: [G; OUT_464] = { let __args: [G; IN_464] = [__v_18, __v_8, __v_23, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[464].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_464] = unsafe { *(result.output.as_ptr() as *const [G; OUT_464]) }; __ret } else { aiur_fn_464(__args, record, io_buffer, __cu)? } };
-            let __v_25: G = __r_arr[0];
-            let __ret: [G; OUT_464] = [__v_25];
-            record.function_queries[464].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_373] = [__v_0];
+            record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64()));
-      },
     }
   })
 }
 
-const INPUT_SIZE_465: usize = 4;
-const IN_465: usize = 4;
-const OUT_465: usize = 1;
-fn aiur_fn_465(
-  inp: [G; IN_465],
+const INPUT_SIZE_374: usize = 2;
+const IN_374: usize = 2;
+const OUT_374: usize = 1;
+fn aiur_fn_374(
+  inp: [G; IN_374],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_465], ExecError> {
+) -> Result<[G; OUT_374], 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_459] = { let __args: [G; IN_459] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[459].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_459] = unsafe { *(result.output.as_ptr() as *const [G; OUT_459]) }; __ret } else { aiur_fn_459(__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];
-    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 __ret: [G; OUT_465] = [__v_6];
-        record.function_queries[465].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
+    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() {
+      5u64 => {
+        let __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[375].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_375] = unsafe { *(result.output.as_ptr() as *const [G; OUT_375]) }; __ret } else { aiur_fn_375(__args, record, io_buffer, __cu)? } };
+        let __v_6: G = __r_arr[0];
+        match __v_6.as_canonical_u64() {
+          1u64 => {
+            let __v_7: G = G::from_u64(1);
+            let __ret: [G; OUT_374] = [__v_7];
+            record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[374].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_374] = unsafe { *(result.output.as_ptr() as *const [G; OUT_374]) }; __ret } else { aiur_fn_374(__args, record, io_buffer, __cu)? } };
+            let __v_7: G = __r_arr[0];
+            let __ret: [G; OUT_374] = [__v_7];
+            record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+        }
       },
       _ => {
-        let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_4, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } };
-        let __v_9: G = __r_arr[0];
-        let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[456].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_456] = unsafe { *(result.output.as_ptr() as *const [G; OUT_456]) }; __ret } else { aiur_fn_456(__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(1);
-        if (__v_10 != __v_12) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_10.as_canonical_u64(), rhs: __v_12.as_canonical_u64() });
-        }
-        let __ret: [G; OUT_465] = [__v_11];
-        record.function_queries[465].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __v_6: G = G::from_u64(0);
+        let __ret: [G; OUT_374] = [__v_6];
+        record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_466: usize = 5;
-const IN_466: usize = 5;
-const OUT_466: usize = 0;
-fn aiur_fn_466(
-  inp: [G; IN_466],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_466], 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_459] = { let __args: [G; IN_459] = [__v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[459].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_459] = unsafe { *(result.output.as_ptr() as *const [G; OUT_459]) }; __ret } else { aiur_fn_459(__args, record, io_buffer, __cu)? } };
-    let __v_5: G = __r_arr[0];
-    let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_5, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } };
-    let __v_6: G = __r_arr[0];
-    let __v_7: G = G::from_u64(1);
-    if (__v_6 != __v_7) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_7.as_canonical_u64() });
-    }
-    let __ret: [G; OUT_466] = [];
-    record.function_queries[466].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_467: usize = 4;
-const IN_467: usize = 4;
-const OUT_467: usize = 1;
-fn aiur_fn_467(
-  inp: [G; IN_467],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_467], 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_400] = { let __args: [G; IN_400] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } };
-    let __v_4: G = __r_arr[0];
-    let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[412].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_412] = unsafe { *(result.output.as_ptr() as *const [G; OUT_412]) }; __ret } else { aiur_fn_412(__args, record, io_buffer, __cu)? } };
-    let __v_5: G = __r_arr[0];
-    let __r_arr: [G; OUT_468] = { let __args: [G; IN_468] = [__v_0, __v_5, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[468].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_468] = unsafe { *(result.output.as_ptr() as *const [G; OUT_468]) }; __ret } else { aiur_fn_468(__args, record, io_buffer, __cu)? } };
-    let __v_6: G = __r_arr[0];
-    let __ret: [G; OUT_467] = [__v_6];
-    record.function_queries[467].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_468: usize = 4;
-const IN_468: usize = 4;
-const OUT_468: usize = 1;
-fn aiur_fn_468(
-  inp: [G; IN_468],
+const INPUT_SIZE_375: usize = 2;
+const IN_375: usize = 2;
+const OUT_375: usize = 1;
+fn aiur_fn_375(
+  inp: [G; IN_375],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_468], ExecError> {
+) -> Result<[G; OUT_375], 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; 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_4: G = __loaded[0];
-    let __v_5: G = __loaded[1];
-    let __v_6: G = __loaded[2];
-    let __v_7: G = __loaded[3];
-    match __v_4.as_canonical_u64() {
-      0u64 => {
-        let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[458].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_458] = unsafe { *(result.output.as_ptr() as *const [G; OUT_458]) }; __ret } else { aiur_fn_458(__args, record, io_buffer, __cu)? } };
-        let __v_8: G = __r_arr[0];
-        let __ret: [G; OUT_468] = [__v_8];
-        record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      1u64 => {
-        let __v_8: G = G::from_u64(1);
-        let __v_9: G = G::from_u64(1);
-        let __v_10: G = G::from_u64(0);
-        let __v_11: G = { let __values: [G; 3] = [__v_9, __v_5, __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_225] = { let __args: [G; IN_225] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[225].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_225] = unsafe { *(result.output.as_ptr() as *const [G; OUT_225]) }; __ret } else { aiur_fn_225(__args, record, io_buffer, __cu)? } };
-        let __v_12: G = __r_arr[0];
-        let __v_13: G = G::from_u64(0);
-        let __v_14: G = { let __values: [G; 4] = [__v_8, __v_12, __v_13, __v_13]; 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_468] = [__v_14];
-        record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
+    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() {
       2u64 => {
-        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-        let __v_8: G = __r_arr[0];
-        let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].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 __v_17: G = __loaded[8];
-        let __v_18: G = __loaded[9];
-        let __v_19: G = __loaded[10];
-        let __r_arr: [G; OUT_471] = { let __args: [G; IN_471] = [__v_9, __v_10, __v_11, __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[471].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_471] = unsafe { *(result.output.as_ptr() as *const [G; OUT_471]) }; __ret } else { aiur_fn_471(__args, record, io_buffer, __cu)? } };
-        let __v_20: G = __r_arr[0];
-        let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { 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_21: G = __r_arr[0];
-        let __r_arr: [G; OUT_470] = { let __args: [G; IN_470] = [__v_9, __v_10, __v_11, __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[470].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_470] = unsafe { *(result.output.as_ptr() as *const [G; OUT_470]) }; __ret } else { aiur_fn_470(__args, record, io_buffer, __cu)? } };
-        let __v_22: G = __r_arr[0];
-        if (__v_21 != __v_20) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_21.as_canonical_u64(), rhs: __v_20.as_canonical_u64() });
-        }
-        let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_22, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } };
-        let __v_23: G = __r_arr[0];
-        let __ret: [G; OUT_468] = [__v_23];
-        record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_376] = { let __args: [G; IN_376] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[376].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_376] = unsafe { *(result.output.as_ptr() as *const [G; OUT_376]) }; __ret } else { aiur_fn_376(__args, record, io_buffer, __cu)? } };
+        let __v_6: G = __r_arr[0];
+        let __ret: [G; OUT_375] = [__v_6];
+        record.function_queries[375].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_467] = { let __args: [G; IN_467] = [__v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[467].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_467] = unsafe { *(result.output.as_ptr() as *const [G; OUT_467]) }; __ret } else { aiur_fn_467(__args, record, io_buffer, __cu)? } };
-        let __v_8: 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_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).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_9: G = __loaded[0];
-        let __v_10: G = __loaded[1];
-        let __v_11: G = __loaded[2];
-        let __v_12: G = __loaded[3];
-        match __v_9.as_canonical_u64() {
-          5u64 => {
-            let __v_13: G = G::from_u64(0);
-            let __r_arr: [G; OUT_419] = { let __args: [G; IN_419] = [__v_11, __v_6, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[419].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_419] = unsafe { *(result.output.as_ptr() as *const [G; OUT_419]) }; __ret } else { aiur_fn_419(__args, record, io_buffer, __cu)? } };
-            let __v_14: G = __r_arr[0];
-            let __ret: [G; OUT_468] = [__v_14];
-            record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[375].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_375] = unsafe { *(result.output.as_ptr() as *const [G; OUT_375]) }; __ret } else { aiur_fn_375(__args, record, io_buffer, __cu)? } };
+        let __v_6: G = __r_arr[0];
+        match __v_6.as_canonical_u64() {
+          1u64 => {
+            let __v_7: G = G::from_u64(1);
+            let __ret: [G; OUT_375] = [__v_7];
+            record.function_queries[375].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_8, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } };
-            let __v_13: G = __r_arr[0];
-            let __r_arr: [G; OUT_457] = { let __args: [G; IN_457] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[457].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_457] = unsafe { *(result.output.as_ptr() as *const [G; OUT_457]) }; __ret } else { aiur_fn_457(__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 __v_17: G = G::from_u64(1);
-            if (__v_14 != __v_17) {
-              return Err(ExecError::AssertEqMismatch { lhs: __v_14.as_canonical_u64(), rhs: __v_17.as_canonical_u64() });
-            }
-            let __v_18: G = G::from_u64(0);
-            let __r_arr: [G; OUT_419] = { let __args: [G; IN_419] = [__v_16, __v_6, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[419].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_419] = unsafe { *(result.output.as_ptr() as *const [G; OUT_419]) }; __ret } else { aiur_fn_419(__args, record, io_buffer, __cu)? } };
-            let __v_19: G = __r_arr[0];
-            let __ret: [G; OUT_468] = [__v_19];
-            record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[375].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_375] = unsafe { *(result.output.as_ptr() as *const [G; OUT_375]) }; __ret } else { aiur_fn_375(__args, record, io_buffer, __cu)? } };
+            let __v_7: G = __r_arr[0];
+            let __ret: [G; OUT_375] = [__v_7];
+            record.function_queries[375].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
       4u64 => {
-        let __v_8: G = G::from_u64(0);
-        let __v_9: G = { let __values: [G; 3] = [__v_8, __v_5, __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_467] = { let __args: [G; IN_467] = [__v_6, __v_9, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[467].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_467] = unsafe { *(result.output.as_ptr() as *const [G; OUT_467]) }; __ret } else { aiur_fn_467(__args, record, io_buffer, __cu)? } };
-        let __v_10: G = __r_arr[0];
-        let __v_11: G = G::from_u64(5);
-        let __v_12: G = G::from_u64(0);
-        let __v_13: G = { let __values: [G; 4] = [__v_11, __v_5, __v_10, __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_468] = [__v_13];
-        record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      5u64 => {
-        let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } else { aiur_fn_469(__args, record, io_buffer, __cu)? } };
-        let __v_8: G = __r_arr[0];
-        let __v_9: G = G::from_u64(0);
-        let __v_10: G = { let __values: [G; 3] = [__v_9, __v_5, __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_469] = { let __args: [G; IN_469] = [__v_6, __v_10, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } else { aiur_fn_469(__args, record, io_buffer, __cu)? } };
-        let __v_11: G = __r_arr[0];
-        let __v_12: G = G::from_u64(1);
-        let __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[224].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_224] = unsafe { *(result.output.as_ptr() as *const [G; OUT_224]) }; __ret } else { aiur_fn_224(__args, record, io_buffer, __cu)? } };
-        let __v_13: G = __r_arr[0];
-        let __v_14: G = G::from_u64(0);
-        let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; 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_468] = [__v_15];
-        record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      6u64 => {
-        let __v_8: G = G::from_u64(0);
-        let __r_arr: [G; OUT_419] = { let __args: [G; IN_419] = [__v_7, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[419].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_419] = unsafe { *(result.output.as_ptr() as *const [G; OUT_419]) }; __ret } else { aiur_fn_419(__args, record, io_buffer, __cu)? } };
-        let __v_9: G = __r_arr[0];
-        let __r_arr: [G; OUT_467] = { let __args: [G; IN_467] = [__v_9, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[467].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_467] = unsafe { *(result.output.as_ptr() as *const [G; OUT_467]) }; __ret } else { aiur_fn_467(__args, record, io_buffer, __cu)? } };
-        let __v_10: G = __r_arr[0];
-        let __ret: [G; OUT_468] = [__v_10];
-        record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      7u64 => {
-        match __v_5.as_canonical_u64() {
-          0u64 => {
-            let __r_arr: [G; OUT_478] = { let __args: [G; IN_478] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[478].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_478] = unsafe { *(result.output.as_ptr() as *const [G; OUT_478]) }; __ret } else { aiur_fn_478(__args, record, io_buffer, __cu)? } };
-            let __v_8: G = __r_arr[0];
-            let __ret: [G; OUT_468] = [__v_8];
-            record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[375].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_375] = unsafe { *(result.output.as_ptr() as *const [G; OUT_375]) }; __ret } else { aiur_fn_375(__args, record, io_buffer, __cu)? } };
+        let __v_6: G = __r_arr[0];
+        match __v_6.as_canonical_u64() {
+          1u64 => {
+            let __v_7: G = G::from_u64(1);
+            let __ret: [G; OUT_375] = [__v_7];
+            record.function_queries[375].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            let __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[375].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_375] = unsafe { *(result.output.as_ptr() as *const [G; OUT_375]) }; __ret } else { aiur_fn_375(__args, record, io_buffer, __cu)? } };
+            let __v_7: G = __r_arr[0];
+            let __ret: [G; OUT_375] = [__v_7];
+            record.function_queries[375].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
+        }
+      },
+      5u64 => {
+        let __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[375].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_375] = unsafe { *(result.output.as_ptr() as *const [G; OUT_375]) }; __ret } else { aiur_fn_375(__args, record, io_buffer, __cu)? } };
+        let __v_6: G = __r_arr[0];
+        match __v_6.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_479] = { let __args: [G; IN_479] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[479].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_479] = unsafe { *(result.output.as_ptr() as *const [G; OUT_479]) }; __ret } else { aiur_fn_479(__args, record, io_buffer, __cu)? } };
-            let __v_8: G = __r_arr[0];
-            let __ret: [G; OUT_468] = [__v_8];
-            record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __v_7: G = G::from_u64(1);
+            let __ret: [G; OUT_375] = [__v_7];
+            record.function_queries[375].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
+            let __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[375].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_375] = unsafe { *(result.output.as_ptr() as *const [G; OUT_375]) }; __ret } else { aiur_fn_375(__args, record, io_buffer, __cu)? } };
+            let __v_7: G = __r_arr[0];
+            let __ret: [G; OUT_375] = [__v_7];
+            record.function_queries[375].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
           },
         }
       },
-      8u64 => {
-        let __r_arr: [G; OUT_467] = { let __args: [G; IN_467] = [__v_7, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[467].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_467] = unsafe { *(result.output.as_ptr() as *const [G; OUT_467]) }; __ret } else { aiur_fn_467(__args, record, io_buffer, __cu)? } };
-        let __v_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_8, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } };
-        let __v_9: G = __r_arr[0];
-        let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[189].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_189] = unsafe { *(result.output.as_ptr() as *const [G; OUT_189]) }; __ret } else { aiur_fn_189(__args, record, io_buffer, __cu)? } };
-        let __v_10: G = __r_arr[0];
-        let __v_11: G = __r_arr[1];
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; 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: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
-        let __v_12: G = __loaded[0];
-        let __v_13: G = __loaded[1];
-        let __v_14: G = __loaded[2];
-        let __v_15: G = __loaded[3];
-        match __v_12.as_canonical_u64() {
-          2u64 => {
-            let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_2, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-            let __v_16: G = __r_arr[0];
-            let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].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];
-            let __v_25: G = __loaded[8];
-            let __v_26: G = __loaded[9];
-            let __v_27: G = __loaded[10];
-            if (__v_13 != __v_5) {
-              return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_5.as_canonical_u64() });
-            }
-            match __v_17.as_canonical_u64() {
-              5u64 => {
-                let __v_28: G = (__v_20 + __v_21);
-                let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_19, __v_14, __v_28, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[476].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_476] = unsafe { *(result.output.as_ptr() as *const [G; OUT_476]) }; __ret } else { aiur_fn_476(__args, record, io_buffer, __cu)? } };
-                let __v_29: G = __r_arr[0];
-                let __v_30: G = G::from_u64(0);
-                let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_22, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-                let __v_31: G = __r_arr[0];
-                let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_2, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-                let __v_32: G = __r_arr[0];
-                let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_32.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr };
-                let __v_33: G = __loaded[0];
-                let __v_34: G = __loaded[1];
-                let __v_35: G = __loaded[2];
-                let __v_36: G = __loaded[3];
-                let __v_37: G = __loaded[4];
-                let __v_38: G = __loaded[5];
-                let __v_39: G = __loaded[6];
-                let __v_40: G = __loaded[7];
-                let __v_41: G = __loaded[8];
-                let __v_42: G = __loaded[9];
-                let __v_43: G = __loaded[10];
-                let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { 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_44: G = __r_arr[0];
-                let __v_45: G = G::from_u64(1);
-                if (__v_44 != __v_45) {
-                  return Err(ExecError::AssertEqMismatch { lhs: __v_44.as_canonical_u64(), rhs: __v_45.as_canonical_u64() });
-                }
-                match __v_33.as_canonical_u64() {
-                  6u64 => {
-                    let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_35, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } };
-                    let __v_46: G = __r_arr[0];
-                    let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_46, __v_11, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[472].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_472] = unsafe { *(result.output.as_ptr() as *const [G; OUT_472]) }; __ret } else { aiur_fn_472(__args, record, io_buffer, __cu)? } };
-                    let __v_47: G = __r_arr[0];
-                    let __v_48: G = G::from_u64(0);
-                    let __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__v_47, __v_6, __v_48, __v_5, __v_7, __v_29, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[473].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_473] = unsafe { *(result.output.as_ptr() as *const [G; OUT_473]) }; __ret } else { aiur_fn_473(__args, record, io_buffer, __cu)? } };
-                    let __v_49: G = __r_arr[0];
-                    let __ret: [G; OUT_468] = [__v_49];
-                    record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
-                  _ => {
-                    return Err(ExecError::MatchNoCase(__v_33.as_canonical_u64()));
-                  },
-                }
+      6u64 => {
+        let __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[375].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_375] = unsafe { *(result.output.as_ptr() as *const [G; OUT_375]) }; __ret } else { aiur_fn_375(__args, record, io_buffer, __cu)? } };
+        let __v_6: G = __r_arr[0];
+        match __v_6.as_canonical_u64() {
+          1u64 => {
+            let __v_7: G = G::from_u64(1);
+            let __ret: [G; OUT_375] = [__v_7];
+            record.function_queries[375].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            let __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[375].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_375] = unsafe { *(result.output.as_ptr() as *const [G; OUT_375]) }; __ret } else { aiur_fn_375(__args, record, io_buffer, __cu)? } };
+            let __v_7: G = __r_arr[0];
+            match __v_7.as_canonical_u64() {
+              1u64 => {
+                let __v_8: G = G::from_u64(1);
+                let __ret: [G; OUT_375] = [__v_8];
+                record.function_queries[375].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
               },
               _ => {
-                return Err(ExecError::MatchNoCase(__v_17.as_canonical_u64()));
+                let __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[375].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_375] = unsafe { *(result.output.as_ptr() as *const [G; OUT_375]) }; __ret } else { aiur_fn_375(__args, record, io_buffer, __cu)? } };
+                let __v_8: G = __r_arr[0];
+                let __ret: [G; OUT_375] = [__v_8];
+                record.function_queries[375].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
               },
             }
           },
+        }
+      },
+      8u64 => {
+        let __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[375].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_375] = unsafe { *(result.output.as_ptr() as *const [G; OUT_375]) }; __ret } else { aiur_fn_375(__args, record, io_buffer, __cu)? } };
+        let __v_6: G = __r_arr[0];
+        let __ret: [G; OUT_375] = [__v_6];
+        record.function_queries[375].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __v_6: G = G::from_u64(0);
+        let __ret: [G; OUT_375] = [__v_6];
+        record.function_queries[375].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_376: usize = 2;
+const IN_376: usize = 2;
+const OUT_376: usize = 1;
+fn aiur_fn_376(
+  inp: [G; IN_376],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_376], 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(0);
+        let __ret: [G; OUT_376] = [__v_5];
+        record.function_queries[376].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_5: G = __r_arr[0];
+        match __v_5.as_canonical_u64() {
+          1u64 => {
+            let __v_6: G = G::from_u64(1);
+            let __ret: [G; OUT_376] = [__v_6];
+            record.function_queries[376].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64()));
+            let __r_arr: [G; OUT_376] = { let __args: [G; IN_376] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[376].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_376] = unsafe { *(result.output.as_ptr() as *const [G; OUT_376]) }; __ret } else { aiur_fn_376(__args, record, io_buffer, __cu)? } };
+            let __v_6: G = __r_arr[0];
+            let __ret: [G; OUT_376] = [__v_6];
+            record.function_queries[376].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
           },
         }
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_469: usize = 4;
-const IN_469: usize = 4;
-const OUT_469: usize = 1;
-fn aiur_fn_469(
-  inp: [G; IN_469],
+const INPUT_SIZE_377: usize = 2;
+const IN_377: usize = 2;
+const OUT_377: usize = 1;
+fn aiur_fn_377(
+  inp: [G; IN_377],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_469], ExecError> {
+) -> Result<[G; OUT_377], 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_467] = { let __args: [G; IN_467] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[467].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_467] = unsafe { *(result.output.as_ptr() as *const [G; OUT_467]) }; __ret } else { aiur_fn_467(__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];
-    let __v_6: G = __loaded[1];
-    let __v_7: G = __loaded[2];
-    let __v_8: G = __loaded[3];
-    match __v_5.as_canonical_u64() {
+    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_469] = [__v_6];
-        record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_377] = [__v_0];
+        record.function_queries[377].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      7u64 => {
+        let __ret: [G; OUT_377] = [__v_0];
+        record.function_queries[377].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      4u64 => {
+        let __ret: [G; OUT_377] = [__v_0];
+        record.function_queries[377].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      5u64 => {
+        let __ret: [G; OUT_377] = [__v_0];
+        record.function_queries[377].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __ret: [G; OUT_377] = [__v_0];
+        record.function_queries[377].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_4, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } };
-        let __v_9: G = __r_arr[0];
-        let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[456].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_456] = unsafe { *(result.output.as_ptr() as *const [G; OUT_456]) }; __ret } else { aiur_fn_456(__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(1);
-        if (__v_10 != __v_12) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_10.as_canonical_u64(), rhs: __v_12.as_canonical_u64() });
-        }
-        let __ret: [G; OUT_469] = [__v_11];
-        record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } };
+        let __v_6: G = __r_arr[0];
+        let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } else { aiur_fn_324(__args, record, io_buffer, __cu)? } };
+        let __v_7: G = __r_arr[0];
+        let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[378].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_378] = unsafe { *(result.output.as_ptr() as *const [G; OUT_378]) }; __ret } else { aiur_fn_378(__args, record, io_buffer, __cu)? } };
+        let __v_8: G = __r_arr[0];
+        let __ret: [G; OUT_377] = [__v_8];
+        record.function_queries[377].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_470: usize = 11;
-const IN_470: usize = 11;
-const OUT_470: usize = 1;
-fn aiur_fn_470(
-  inp: [G; IN_470],
+const INPUT_SIZE_378: usize = 2;
+const IN_378: usize = 2;
+const OUT_378: usize = 1;
+fn aiur_fn_378(
+  inp: [G; IN_378],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_470], ExecError> {
+) -> Result<[G; OUT_378], 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];
-    match __v_0.as_canonical_u64() {
-      0u64 => {
-        let __ret: [G; OUT_470] = [__v_2];
-        record.function_queries[470].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
+    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_341] = { let __args: [G; IN_341] = [__v_0, __v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } else { aiur_fn_341(__args, record, io_buffer, __cu)? } };
+    let __v_5: G = __r_arr[0];
+    let __ret: [G; OUT_378] = [__v_5];
+    record.function_queries[378].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_379: usize = 2;
+const IN_379: usize = 2;
+const OUT_379: usize = 1;
+fn aiur_fn_379(
+  inp: [G; IN_379],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_379], 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_470] = [__v_2];
-        record.function_queries[470].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      2u64 => {
-        let __ret: [G; OUT_470] = [__v_2];
-        record.function_queries[470].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_379] = [__v_0];
+        record.function_queries[379].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      3u64 => {
-        let __ret: [G; OUT_470] = [__v_2];
-        record.function_queries[470].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+      7u64 => {
+        let __ret: [G; OUT_379] = [__v_0];
+        record.function_queries[379].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       4u64 => {
-        let __ret: [G; OUT_470] = [__v_2];
-        record.function_queries[470].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_379] = [__v_0];
+        record.function_queries[379].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       5u64 => {
-        let __ret: [G; OUT_470] = [__v_2];
-        record.function_queries[470].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      6u64 => {
-        let __ret: [G; OUT_470] = [__v_2];
-        record.function_queries[470].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_379] = [__v_0];
+        record.function_queries[379].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      7u64 => {
-        let __ret: [G; OUT_470] = [__v_2];
-        record.function_queries[470].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+      0u64 => {
+        let __ret: [G; OUT_379] = [__v_0];
+        record.function_queries[379].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64()));
+        let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } };
+        let __v_6: G = __r_arr[0];
+        let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } else { aiur_fn_324(__args, record, io_buffer, __cu)? } };
+        let __v_7: G = __r_arr[0];
+        let __r_arr: [G; OUT_380] = { let __args: [G; IN_380] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[380].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_380] = unsafe { *(result.output.as_ptr() as *const [G; OUT_380]) }; __ret } else { aiur_fn_380(__args, record, io_buffer, __cu)? } };
+        let __v_8: G = __r_arr[0];
+        let __ret: [G; OUT_379] = [__v_8];
+        record.function_queries[379].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_471: usize = 11;
-const IN_471: usize = 11;
-const OUT_471: usize = 1;
-fn aiur_fn_471(
-  inp: [G; IN_471],
+const INPUT_SIZE_380: usize = 2;
+const IN_380: usize = 2;
+const OUT_380: usize = 1;
+fn aiur_fn_380(
+  inp: [G; IN_380],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_471], ExecError> {
+) -> Result<[G; OUT_380], 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_381] = { let __args: [G; IN_381] = [__v_0, __v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[381].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_381] = unsafe { *(result.output.as_ptr() as *const [G; OUT_381]) }; __ret } else { aiur_fn_381(__args, record, io_buffer, __cu)? } };
+    let __v_5: G = __r_arr[0];
+    let __ret: [G; OUT_380] = [__v_5];
+    record.function_queries[380].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_381: usize = 3;
+const IN_381: usize = 3;
+const OUT_381: usize = 1;
+fn aiur_fn_381(
+  inp: [G; IN_381],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_381], 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];
-    match __v_0.as_canonical_u64() {
-      0u64 => {
-        let __ret: [G; OUT_471] = [__v_1];
-        record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      1u64 => {
-        let __ret: [G; OUT_471] = [__v_1];
-        record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      2u64 => {
-        let __ret: [G; OUT_471] = [__v_1];
-        record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
+    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_3: G = __loaded[0];
+    let __v_4: G = __loaded[1];
+    let __v_5: G = __loaded[2];
+    let __v_6: G = __loaded[3];
+    match __v_3.as_canonical_u64() {
       3u64 => {
-        let __ret: [G; OUT_471] = [__v_1];
-        record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[106].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_106] = unsafe { *(result.output.as_ptr() as *const [G; OUT_106]) }; __ret } else { aiur_fn_106(__args, record, io_buffer, __cu)? } };
+        let __v_7: G = __r_arr[0];
+        let __v_8: G = __r_arr[1];
+        let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[710].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_710] = unsafe { *(result.output.as_ptr() as *const [G; OUT_710]) }; __ret } else { aiur_fn_710(__args, record, io_buffer, __cu)? } };
+        let __v_9: G = __r_arr[0];
+        let __r_arr: [G; OUT_381] = { let __args: [G; IN_381] = [__v_7, __v_9, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[381].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_381] = unsafe { *(result.output.as_ptr() as *const [G; OUT_381]) }; __ret } else { aiur_fn_381(__args, record, io_buffer, __cu)? } };
+        let __v_10: G = __r_arr[0];
+        let __ret: [G; OUT_381] = [__v_10];
+        record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       4u64 => {
-        let __ret: [G; OUT_471] = [__v_1];
-        record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[382].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_382] = unsafe { *(result.output.as_ptr() as *const [G; OUT_382]) }; __ret } else { aiur_fn_382(__args, record, io_buffer, __cu)? } };
+        let __v_7: G = __r_arr[0];
+        let __ret: [G; OUT_381] = [__v_7];
+        record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      5u64 => {
-        let __ret: [G; OUT_471] = [__v_1];
-        record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+      2u64 => {
+        let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_4, __v_5, __v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } };
+        let __v_7: G = __r_arr[0];
+        let __ret: [G; OUT_381] = [__v_7];
+        record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       6u64 => {
-        let __ret: [G; OUT_471] = [__v_1];
-        record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __v_7: G = G::from_u64(0);
+        let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_6, __v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[331].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_331] = unsafe { *(result.output.as_ptr() as *const [G; OUT_331]) }; __ret } else { aiur_fn_331(__args, record, io_buffer, __cu)? } };
+        let __v_8: G = __r_arr[0];
+        let __r_arr: [G; OUT_381] = { let __args: [G; IN_381] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[381].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_381] = unsafe { *(result.output.as_ptr() as *const [G; OUT_381]) }; __ret } else { aiur_fn_381(__args, record, io_buffer, __cu)? } };
+        let __v_9: G = __r_arr[0];
+        let __ret: [G; OUT_381] = [__v_9];
+        record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      7u64 => {
-        let __ret: [G; OUT_471] = [__v_1];
-        record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+      8u64 => {
+        let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } };
+        let __v_7: G = __r_arr[0];
+        let __ret: [G; OUT_381] = [__v_7];
+        record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64()));
+        let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } };
+        let __v_7: G = __r_arr[0];
+        let __ret: [G; OUT_381] = [__v_7];
+        record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_472: usize = 3;
-const IN_472: usize = 3;
-const OUT_472: usize = 1;
-fn aiur_fn_472(
-  inp: [G; IN_472],
+const INPUT_SIZE_382: usize = 3;
+const IN_382: usize = 3;
+const OUT_382: usize = 1;
+fn aiur_fn_382(
+  inp: [G; IN_382],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_472], ExecError> {
+) -> Result<[G; OUT_382], 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_2.as_canonical_u64() {
+    let __v_3: G = G::from_u64(1);
+    let __v_4: G = G::from_u64(1);
+    let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __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 __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_1, __v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = unsafe { *(result.output.as_ptr() as *const [G; OUT_339]) }; __ret } else { aiur_fn_339(__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 __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } else { aiur_fn_711(__args, record, io_buffer, __cu)? } };
+    let __v_9: G = __r_arr[0];
+    match __v_9.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_472] = [__v_0];
-        record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_1, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } };
+        let __v_10: G = __r_arr[0];
+        let __ret: [G; OUT_382] = [__v_10];
+        record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      1u64 => {
+        let __v_10: G = G::from_u64(0);
+        let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } };
+        let __v_11: G = __r_arr[0];
+        let __v_12: G = G::from_u64(0);
+        let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_6, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[331].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_331] = unsafe { *(result.output.as_ptr() as *const [G; OUT_331]) }; __ret } else { aiur_fn_331(__args, record, io_buffer, __cu)? } };
+        let __v_13: G = __r_arr[0];
+        let __r_arr: [G; OUT_381] = { let __args: [G; IN_381] = [__v_13, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[381].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_381] = unsafe { *(result.output.as_ptr() as *const [G; OUT_381]) }; __ret } else { aiur_fn_381(__args, record, io_buffer, __cu)? } };
+        let __v_14: G = __r_arr[0];
+        let __ret: [G; OUT_382] = [__v_14];
+        record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        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_3: G = __loaded[0];
-        let __v_4: G = __loaded[1];
-        let __v_5: G = __loaded[2];
-        let __v_6: G = __loaded[3];
-        match __v_3.as_canonical_u64() {
-          5u64 => {
-            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_7: G = __loaded[0];
-            let __v_8: G = __loaded[1];
-            let __v_9: G = __loaded[2];
-            match __v_7.as_canonical_u64() {
-              0u64 => {
-                let __v_10: G = G::from_u64(0);
-                let __r_arr: [G; OUT_419] = { let __args: [G; IN_419] = [__v_5, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[419].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_419] = unsafe { *(result.output.as_ptr() as *const [G; OUT_419]) }; __ret } else { aiur_fn_419(__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_2 - __v_12);
-                let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_11, __v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[472].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_472] = unsafe { *(result.output.as_ptr() as *const [G; OUT_472]) }; __ret } else { aiur_fn_472(__args, record, io_buffer, __cu)? } };
-                let __v_14: G = __r_arr[0];
-                let __ret: [G; OUT_472] = [__v_14];
-                record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              _ => {
-                return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64()));
-              },
-            }
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
-          },
-        }
+        let __v_10: G = G::from_u64(0);
+        let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_6, __v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } else { aiur_fn_335(__args, record, io_buffer, __cu)? } };
+        let __v_11: G = __r_arr[0];
+        let __r_arr: [G; OUT_381] = { let __args: [G; IN_381] = [__v_11, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[381].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_381] = unsafe { *(result.output.as_ptr() as *const [G; OUT_381]) }; __ret } else { aiur_fn_381(__args, record, io_buffer, __cu)? } };
+        let __v_12: G = __r_arr[0];
+        let __ret: [G; OUT_382] = [__v_12];
+        record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_473: usize = 9;
-const IN_473: usize = 9;
-const OUT_473: usize = 1;
-fn aiur_fn_473(
-  inp: [G; IN_473],
+const INPUT_SIZE_383: usize = 5;
+const IN_383: usize = 5;
+const OUT_383: usize = 1;
+fn aiur_fn_383(
+  inp: [G; IN_383],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_473], ExecError> {
+) -> Result<[G; OUT_383], 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; 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_9: G = __loaded[0];
-    let __v_10: G = __loaded[1];
-    let __v_11: G = __loaded[2];
-    let __v_12: G = __loaded[3];
+    let __r_arr: [G; OUT_379] = { let __args: [G; IN_379] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[379].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_379] = unsafe { *(result.output.as_ptr() as *const [G; OUT_379]) }; __ret } else { aiur_fn_379(__args, record, io_buffer, __cu)? } };
+    let __v_5: G = __r_arr[0];
+    let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_5, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { 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_6: G = __r_arr[0];
+    let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[106].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_106] = unsafe { *(result.output.as_ptr() as *const [G; OUT_106]) }; __ret } else { aiur_fn_106(__args, record, io_buffer, __cu)? } };
+    let __v_7: G = __r_arr[0];
+    let __v_8: G = __r_arr[1];
+    let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_0, __v_1, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[346].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_346] = unsafe { *(result.output.as_ptr() as *const [G; OUT_346]) }; __ret } else { aiur_fn_346(__args, record, io_buffer, __cu)? } };
+    let __v_9: G = __r_arr[0];
+    let __v_10: G = __r_arr[1];
     match __v_9.as_canonical_u64() {
-      5u64 => {
-        let __v_13: G = (__v_1 - __v_2);
-        match __v_13.as_canonical_u64() {
-          0u64 => {
-            let __r_arr: [G; OUT_477] = { let __args: [G; IN_477] = [__v_5, __v_10, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[477].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_477] = unsafe { *(result.output.as_ptr() as *const [G; OUT_477]) }; __ret } else { aiur_fn_477(__args, record, io_buffer, __cu)? } };
-            let __ret: [G; OUT_473] = [__v_10];
-            record.function_queries[473].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
+      1u64 => {
+        let __r_arr: [G; OUT_381] = { let __args: [G; IN_381] = [__v_10, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[381].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_381] = unsafe { *(result.output.as_ptr() as *const [G; OUT_381]) }; __ret } else { aiur_fn_381(__args, record, io_buffer, __cu)? } };
+        let __v_11: G = __r_arr[0];
+        let __ret: [G; OUT_383] = [__v_11];
+        record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; 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: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].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];
+        match __v_11.as_canonical_u64() {
+          2u64 => {
+            let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[347].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_347] = unsafe { *(result.output.as_ptr() as *const [G; OUT_347]) }; __ret } else { aiur_fn_347(__args, record, io_buffer, __cu)? } };
+            let __v_15: G = __r_arr[0];
+            let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; 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: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+            let __v_16: G = __loaded[0];
+            let __v_17: G = __loaded[1];
+            let __v_18: G = __loaded[2];
+            let __v_19: G = __loaded[3];
+            let __v_20: G = __loaded[4];
+            let __v_21: G = __loaded[5];
+            let __v_22: G = __loaded[6];
+            let __v_23: G = __loaded[7];
+            let __v_24: G = __loaded[8];
+            let __v_25: G = __loaded[9];
+            let __v_26: G = __loaded[10];
+            let __v_27: G = __loaded[11];
+            match __v_16.as_canonical_u64() {
+              6u64 => {
+                let __v_28: G = (__v_22 + __v_1);
+                let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_8, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } };
+                let __v_29: G = __r_arr[0];
+                let __r_arr: [G; OUT_381] = { let __args: [G; IN_381] = [__v_29, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[381].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_381] = unsafe { *(result.output.as_ptr() as *const [G; OUT_381]) }; __ret } else { aiur_fn_381(__args, record, io_buffer, __cu)? } };
+                let __v_30: G = __r_arr[0];
+                let __ret: [G; OUT_383] = [__v_30];
+                record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                let __v_28: G = G::from_u64(8);
+                let __v_29: G = { let __values: [G; 4] = [__v_28, __v_0, __v_1, __v_5]; 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_228] = { let __args: [G; IN_228] = [__v_29, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } };
+                let __v_30: G = __r_arr[0];
+                let __ret: [G; OUT_383] = [__v_30];
+                record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+            }
           },
           _ => {
-            let __r_arr: [G; OUT_474] = { let __args: [G; IN_474] = [__v_5, __v_10, __v_11, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[474].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_474] = unsafe { *(result.output.as_ptr() as *const [G; OUT_474]) }; __ret } else { aiur_fn_474(__args, record, io_buffer, __cu)? } };
-            let __v_14: G = G::from_u64(8);
-            let __v_15: G = { let __values: [G; 4] = [__v_14, __v_3, __v_2, __v_4]; 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_16: G = G::from_u64(0);
-            let __r_arr: [G; OUT_419] = { let __args: [G; IN_419] = [__v_11, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[419].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_419] = unsafe { *(result.output.as_ptr() as *const [G; OUT_419]) }; __ret } else { aiur_fn_419(__args, record, io_buffer, __cu)? } };
+            let __v_15: G = G::from_u64(8);
+            let __v_16: G = { let __values: [G; 4] = [__v_15, __v_0, __v_1, __v_5]; 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_228] = { let __args: [G; IN_228] = [__v_16, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__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_2 + __v_18);
-            let __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__v_17, __v_1, __v_19, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[473].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_473] = unsafe { *(result.output.as_ptr() as *const [G; OUT_473]) }; __ret } else { aiur_fn_473(__args, record, io_buffer, __cu)? } };
-            let __v_20: G = __r_arr[0];
-            let __ret: [G; OUT_473] = [__v_20];
-            record.function_queries[473].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_383] = [__v_17];
+            record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64()));
-      },
     }
   })
 }
 
-const INPUT_SIZE_474: usize = 6;
-const IN_474: usize = 6;
-const OUT_474: usize = 0;
-fn aiur_fn_474(
-  inp: [G; IN_474],
+const INPUT_SIZE_384: usize = 5;
+const IN_384: usize = 5;
+const OUT_384: usize = 1;
+fn aiur_fn_384(
+  inp: [G; IN_384],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_474], ExecError> {
+) -> Result<[G; OUT_384], 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];
-    match __v_0.as_canonical_u64() {
-      0u64 => {
-        let __ret: [G; OUT_474] = [];
-        record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __r_arr: [G; OUT_352] = { let __args: [G; IN_352] = [__v_0, __v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[352].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_352] = unsafe { *(result.output.as_ptr() as *const [G; OUT_352]) }; __ret } else { aiur_fn_352(__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() {
+      1u64 => {
+        let __r_arr: [G; OUT_379] = { let __args: [G; IN_379] = [__v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[379].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_379] = unsafe { *(result.output.as_ptr() as *const [G; OUT_379]) }; __ret } else { aiur_fn_379(__args, record, io_buffer, __cu)? } };
+        let __v_7: G = __r_arr[0];
+        let __ret: [G; OUT_384] = [__v_7];
+        record.function_queries[384].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      2u64 => {
+        let __ret: [G; OUT_384] = [__v_6];
+        record.function_queries[384].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_465] = { let __args: [G; IN_465] = [__v_1, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[465].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_465] = unsafe { *(result.output.as_ptr() as *const [G; OUT_465]) }; __ret } else { aiur_fn_465(__args, record, io_buffer, __cu)? } };
-        let __v_6: G = __r_arr[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_7, __v_8, __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 __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[216].get_mut(&__args[..]) { 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_10: G = __r_arr[0];
-        match __v_10.as_canonical_u64() {
+        let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[258].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_258] = unsafe { *(result.output.as_ptr() as *const [G; OUT_258]) }; __ret } else { aiur_fn_258(__args, record, io_buffer, __cu)? } };
+        let __v_7: G = __r_arr[0];
+        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; 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: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].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];
+        let __v_18: G = __loaded[10];
+        let __v_19: G = __loaded[11];
+        match __v_8.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_474] = [];
-            record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
+            let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[358].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_358] = unsafe { *(result.output.as_ptr() as *const [G; OUT_358]) }; __ret } else { aiur_fn_358(__args, record, io_buffer, __cu)? } };
+            let __v_20: G = __r_arr[0];
+            let __v_21: G = __r_arr[1];
+            match __v_20.as_canonical_u64() {
+              1u64 => {
+                let __r_arr: [G; OUT_379] = { let __args: [G; IN_379] = [__v_21, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[379].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_379] = unsafe { *(result.output.as_ptr() as *const [G; OUT_379]) }; __ret } else { aiur_fn_379(__args, record, io_buffer, __cu)? } };
+                let __v_22: G = __r_arr[0];
+                let __ret: [G; OUT_384] = [__v_22];
+                record.function_queries[384].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } };
+                let __v_22: G = __r_arr[0];
+                let __ret: [G; OUT_384] = [__v_22];
+                record.function_queries[384].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+            }
           },
-          _ => {
-            let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } };
-            let __v_11: G = __r_arr[0];
-            let __v_12: G = G::from_u64(0);
-            if (__v_11 != __v_12) {
-              return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_12.as_canonical_u64() });
+          4u64 => {
+            let __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = [__v_11, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[353].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_353] = unsafe { *(result.output.as_ptr() as *const [G; OUT_353]) }; __ret } else { aiur_fn_353(__args, record, io_buffer, __cu)? } };
+            let __v_20: G = __r_arr[0];
+            let __v_21: G = __r_arr[1];
+            match __v_20.as_canonical_u64() {
+              1u64 => {
+                let __r_arr: [G; OUT_379] = { let __args: [G; IN_379] = [__v_21, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[379].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_379] = unsafe { *(result.output.as_ptr() as *const [G; OUT_379]) }; __ret } else { aiur_fn_379(__args, record, io_buffer, __cu)? } };
+                let __v_22: G = __r_arr[0];
+                let __ret: [G; OUT_384] = [__v_22];
+                record.function_queries[384].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } };
+                let __v_22: G = __r_arr[0];
+                let __ret: [G; OUT_384] = [__v_22];
+                record.function_queries[384].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+            }
+          },
+          7u64 => {
+            let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_10, __v_11, __v_13, __v_14, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[570].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_570] = unsafe { *(result.output.as_ptr() as *const [G; OUT_570]) }; __ret } else { aiur_fn_570(__args, record, io_buffer, __cu)? } };
+            let __v_20: G = __r_arr[0];
+            let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_1, __v_3, __v_11, __v_13, __v_14, __v_12, __v_15, __v_4, __v_2, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } else { aiur_fn_364(__args, record, io_buffer, __cu)? } };
+            let __v_21: G = __r_arr[0];
+            let __v_22: G = __r_arr[1];
+            match __v_21.as_canonical_u64() {
+              1u64 => {
+                let __r_arr: [G; OUT_379] = { let __args: [G; IN_379] = [__v_22, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[379].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_379] = unsafe { *(result.output.as_ptr() as *const [G; OUT_379]) }; __ret } else { aiur_fn_379(__args, record, io_buffer, __cu)? } };
+                let __v_23: G = __r_arr[0];
+                let __ret: [G; OUT_384] = [__v_23];
+                record.function_queries[384].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } };
+                let __v_23: G = __r_arr[0];
+                let __ret: [G; OUT_384] = [__v_23];
+                record.function_queries[384].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
             }
-            let __ret: [G; OUT_474] = [];
-            record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+          },
+          _ => {
+            let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } };
+            let __v_20: G = __r_arr[0];
+            let __ret: [G; OUT_384] = [__v_20];
+            record.function_queries[384].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -42624,67 +34133,40 @@ fn aiur_fn_474(
   })
 }
 
-const INPUT_SIZE_475: usize = 5;
-const IN_475: usize = 5;
-const OUT_475: usize = 1;
-fn aiur_fn_475(
-  inp: [G; IN_475],
+const INPUT_SIZE_385: usize = 2;
+const IN_385: usize = 2;
+const OUT_385: usize = 1;
+fn aiur_fn_385(
+  inp: [G; IN_385],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_475], ExecError> {
+) -> Result<[G; OUT_385], 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_1.as_canonical_u64() {
-      0u64 => {
-        let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } };
-        let __v_5: G = __r_arr[0];
-        let __ret: [G; OUT_475] = [__v_5];
-        record.function_queries[475].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } };
-        let __v_5: 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_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: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].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];
-        match __v_6.as_canonical_u64() {
-          5u64 => {
-            let __v_10: G = G::from_u64(1);
-            let __v_11: G = (__v_1 - __v_10);
-            let __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_8, __v_11, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[475].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_475] = unsafe { *(result.output.as_ptr() as *const [G; OUT_475]) }; __ret } else { aiur_fn_475(__args, record, io_buffer, __cu)? } };
-            let __v_12: G = __r_arr[0];
-            let __ret: [G; OUT_475] = [__v_12];
-            record.function_queries[475].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            let __ret: [G; OUT_475] = [__v_5];
-            record.function_queries[475].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-        }
-      },
-    }
+    let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } };
+    let __v_2: G = __r_arr[0];
+    let __v_3: G = G::from_u64(1);
+    let __v_4: G = (__v_1 + __v_3);
+    let __v_5: G = G::from_u64(0);
+    let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_2, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[325].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_325] = unsafe { *(result.output.as_ptr() as *const [G; OUT_325]) }; __ret } else { aiur_fn_325(__args, record, io_buffer, __cu)? } };
+    let __v_6: G = __r_arr[0];
+    let __ret: [G; OUT_385] = [__v_6];
+    record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_476: usize = 6;
-const IN_476: usize = 6;
-const OUT_476: usize = 1;
-fn aiur_fn_476(
-  inp: [G; IN_476],
+const INPUT_SIZE_386: usize = 12;
+const IN_386: usize = 12;
+const OUT_386: usize = 1;
+fn aiur_fn_386(
+  inp: [G; IN_386],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_476], ExecError> {
+) -> Result<[G; OUT_386], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -42692,474 +34174,540 @@ fn aiur_fn_476(
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
-    let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } };
-    let __v_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_6, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[475].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_475] = unsafe { *(result.output.as_ptr() as *const [G; OUT_475]) }; __ret } else { aiur_fn_475(__args, record, io_buffer, __cu)? } };
-    let __v_7: 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_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: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].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];
-    match __v_8.as_canonical_u64() {
+    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];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __ret: [G; OUT_386] = [__v_1];
+        record.function_queries[386].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
       1u64 => {
-        let __v_12: G = G::from_u64(0);
-        let __v_13: G = G::from_u64(0);
-        let __v_14: G = { let __values: [G; 3] = [__v_12, __v_13, __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 __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_9, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[216].get_mut(&__args[..]) { 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_15: G = __r_arr[0];
-        let __ret: [G; OUT_476] = [__v_15];
-        record.function_queries[476].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_386] = [__v_1];
+        record.function_queries[386].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      _ => {
-        let __v_12: G = G::from_u64(0);
-        let __ret: [G; OUT_476] = [__v_12];
-        record.function_queries[476].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+      2u64 => {
+        let __ret: [G; OUT_386] = [__v_1];
+        record.function_queries[386].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      3u64 => {
+        let __ret: [G; OUT_386] = [__v_1];
+        record.function_queries[386].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      4u64 => {
+        let __ret: [G; OUT_386] = [__v_1];
+        record.function_queries[386].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      5u64 => {
+        let __ret: [G; OUT_386] = [__v_1];
+        record.function_queries[386].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      6u64 => {
+        let __ret: [G; OUT_386] = [__v_1];
+        record.function_queries[386].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      7u64 => {
+        let __ret: [G; OUT_386] = [__v_1];
+        record.function_queries[386].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64()));
+      },
     }
   })
 }
 
-const INPUT_SIZE_477: usize = 5;
-const IN_477: usize = 5;
-const OUT_477: usize = 0;
-fn aiur_fn_477(
-  inp: [G; IN_477],
+const INPUT_SIZE_387: usize = 12;
+const IN_387: usize = 12;
+const OUT_387: usize = 1;
+fn aiur_fn_387(
+  inp: [G; IN_387],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_477], ExecError> {
+) -> Result<[G; OUT_387], 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];
     match __v_0.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_477] = [];
-        record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_387] = [__v_2];
+        record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      1u64 => {
+        let __ret: [G; OUT_387] = [__v_2];
+        record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      2u64 => {
+        let __ret: [G; OUT_387] = [__v_2];
+        record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      3u64 => {
+        let __ret: [G; OUT_387] = [__v_2];
+        record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      _ => {
-        let __r_arr: [G; OUT_465] = { let __args: [G; IN_465] = [__v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[465].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_465] = unsafe { *(result.output.as_ptr() as *const [G; OUT_465]) }; __ret } else { aiur_fn_465(__args, record, io_buffer, __cu)? } };
-        let __v_5: G = __r_arr[0];
-        let __v_6: G = G::from_u64(0);
-        let __v_7: G = G::from_u64(0);
-        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 __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[216].get_mut(&__args[..]) { 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);
-        if (__v_9 != __v_10) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_10.as_canonical_u64() });
-        }
-        let __ret: [G; OUT_477] = [];
-        record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+      4u64 => {
+        let __ret: [G; OUT_387] = [__v_2];
+        record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      5u64 => {
+        let __ret: [G; OUT_387] = [__v_2];
+        record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      6u64 => {
+        let __ret: [G; OUT_387] = [__v_2];
+        record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      7u64 => {
+        let __ret: [G; OUT_387] = [__v_2];
+        record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64()));
+      },
     }
   })
 }
 
-const INPUT_SIZE_478: usize = 1;
-const IN_478: usize = 1;
-const OUT_478: usize = 1;
-fn aiur_fn_478(
-  inp: [G; IN_478],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_478], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[271].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_271] = unsafe { *(result.output.as_ptr() as *const [G; OUT_271]) }; __ret } else { aiur_fn_271(__args, record, io_buffer, __cu)? } };
-    let __v_1: G = __r_arr[0];
-    let __v_2: G = G::from_u64(0);
-    let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[480].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_480] = unsafe { *(result.output.as_ptr() as *const [G; OUT_480]) }; __ret } else { aiur_fn_480(__args, record, io_buffer, __cu)? } };
-    let __v_3: G = __r_arr[0];
-    let __v_4: G = G::from_u64(2);
-    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 __v_8: G = G::from_u64(0);
-    let __v_9: G = { let __values: [G; 4] = [__v_4, __v_3, __v_7, __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_478] = [__v_9];
-    record.function_queries[478].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_479: usize = 1;
-const IN_479: usize = 1;
-const OUT_479: usize = 1;
-fn aiur_fn_479(
-  inp: [G; IN_479],
+const INPUT_SIZE_388: usize = 2;
+const IN_388: usize = 2;
+const OUT_388: usize = 1;
+fn aiur_fn_388(
+  inp: [G; IN_388],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_479], ExecError> {
+) -> Result<[G; OUT_388], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } else { aiur_fn_289(__args, record, io_buffer, __cu)? } };
-    let __v_1: G = __r_arr[0];
-    let __v_2: G = G::from_u64(0);
-    let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[480].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_480] = unsafe { *(result.output.as_ptr() as *const [G; OUT_480]) }; __ret } else { aiur_fn_480(__args, record, io_buffer, __cu)? } };
+    let __v_1: G = inp[1];
+    let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } };
+    let __v_2: G = __r_arr[0];
+    let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } else { aiur_fn_324(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
-    let __v_4: G = G::from_u64(2);
-    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 __v_8: G = G::from_u64(0);
-    let __v_9: G = { let __values: [G; 4] = [__v_4, __v_3, __v_7, __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_479] = [__v_9];
-    record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __r_arr: [G; OUT_389] = { let __args: [G; IN_389] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[389].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_389] = unsafe { *(result.output.as_ptr() as *const [G; OUT_389]) }; __ret } else { aiur_fn_389(__args, record, io_buffer, __cu)? } };
+    let __v_4: G = __r_arr[0];
+    let __ret: [G; OUT_388] = [__v_4];
+    record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_480: usize = 3;
-const IN_480: usize = 3;
-const OUT_480: usize = 1;
-fn aiur_fn_480(
-  inp: [G; IN_480],
+const INPUT_SIZE_389: usize = 2;
+const IN_389: usize = 2;
+const OUT_389: usize = 1;
+fn aiur_fn_389(
+  inp: [G; IN_389],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_480], ExecError> {
+) -> Result<[G; OUT_389], 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_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_3: G = __loaded[0];
-    let __v_4: G = __loaded[1];
-    let __v_5: G = __loaded[2];
-    match __v_3.as_canonical_u64() {
+    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() {
       0u64 => {
-        let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_385] = { let __args: [G; IN_385] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = unsafe { *(result.output.as_ptr() as *const [G; OUT_385]) }; __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
-        match __v_6.as_canonical_u64() {
-          1u64 => {
-            let __ret: [G; OUT_480] = [__v_2];
-            record.function_queries[480].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          0u64 => {
-            let __v_7: G = G::from_u64(1);
-            let __v_8: G = (__v_2 + __v_7);
-            let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_0, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[480].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_480] = unsafe { *(result.output.as_ptr() as *const [G; OUT_480]) }; __ret } else { aiur_fn_480(__args, record, io_buffer, __cu)? } };
-            let __v_9: G = __r_arr[0];
-            let __ret: [G; OUT_480] = [__v_9];
-            record.function_queries[480].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_389] = [__v_6];
+        record.function_queries[389].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      1u64 => {
+        let __v_6: G = G::from_u64(1);
+        let __v_7: G = G::from_u64(1);
+        let __v_8: G = G::from_u64(0);
+        let __v_9: G = { let __values: [G; 3] = [__v_7, __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 __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[304].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_304] = unsafe { *(result.output.as_ptr() as *const [G; OUT_304]) }; __ret } else { aiur_fn_304(__args, record, io_buffer, __cu)? } };
+        let __v_10: G = __r_arr[0];
+        let __v_11: G = G::from_u64(0);
+        let __v_12: G = { let __values: [G; 4] = [__v_6, __v_10, __v_11, __v_11]; 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_389] = [__v_12];
+        record.function_queries[389].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      2u64 => {
+        let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[258].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_258] = unsafe { *(result.output.as_ptr() as *const [G; OUT_258]) }; __ret } else { aiur_fn_258(__args, record, io_buffer, __cu)? } };
+        let __v_6: G = __r_arr[0];
+        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; 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: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].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];
+        let __v_17: G = __loaded[10];
+        let __v_18: G = __loaded[11];
+        let __r_arr: [G; OUT_386] = { let __args: [G; IN_386] = [__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[386].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_386] = unsafe { *(result.output.as_ptr() as *const [G; OUT_386]) }; __ret } else { aiur_fn_386(__args, record, io_buffer, __cu)? } };
+        let __v_19: G = __r_arr[0];
+        let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__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[387].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_387] = unsafe { *(result.output.as_ptr() as *const [G; OUT_387]) }; __ret } else { aiur_fn_387(__args, record, io_buffer, __cu)? } };
+        let __v_20: G = __r_arr[0];
+        let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } else { aiur_fn_711(__args, record, io_buffer, __cu)? } };
+        let __v_21: G = __r_arr[0];
+        if (__v_21 != __v_19) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_21.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: Some("Const applied to wrong number of universe levels".to_string()) });
+        }
+        let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_20, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } else { aiur_fn_307(__args, record, io_buffer, __cu)? } };
+        let __v_22: G = __r_arr[0];
+        let __ret: [G; OUT_389] = [__v_22];
+        record.function_queries[389].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      3u64 => {
+        let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[388].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_388] = unsafe { *(result.output.as_ptr() as *const [G; OUT_388]) }; __ret } else { aiur_fn_388(__args, record, io_buffer, __cu)? } };
+        let __v_6: 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_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: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].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];
+        match __v_7.as_canonical_u64() {
+          5u64 => {
+            let __v_11: G = G::from_u64(0);
+            let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_9, __v_4, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[331].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_331] = unsafe { *(result.output.as_ptr() as *const [G; OUT_331]) }; __ret } else { aiur_fn_331(__args, record, io_buffer, __cu)? } };
+            let __v_12: G = __r_arr[0];
+            let __ret: [G; OUT_389] = [__v_12];
+            record.function_queries[389].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64()));
+            let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = unsafe { *(result.output.as_ptr() as *const [G; OUT_377]) }; __ret } else { aiur_fn_377(__args, record, io_buffer, __cu)? } };
+            let __v_11: 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_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).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_12: G = __loaded[0];
+            let __v_13: G = __loaded[1];
+            let __v_14: G = __loaded[2];
+            let __v_15: G = __loaded[3];
+            match __v_12.as_canonical_u64() {
+              5u64 => {
+                let __v_16: G = G::from_u64(0);
+                let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_14, __v_4, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[331].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_331] = unsafe { *(result.output.as_ptr() as *const [G; OUT_331]) }; __ret } else { aiur_fn_331(__args, record, io_buffer, __cu)? } };
+                let __v_17: G = __r_arr[0];
+                let __ret: [G; OUT_389] = [__v_17];
+                record.function_queries[389].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64()));
+              },
+            }
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_481: usize = 5;
-const IN_481: usize = 5;
-const OUT_481: usize = 1;
-fn aiur_fn_481(
-  inp: [G; IN_481],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_481], 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 = (__v_0 - __v_1);
-    match __v_5.as_canonical_u64() {
-      0u64 => {
-        let __v_6: G = G::from_u64(1);
-        let __ret: [G; OUT_481] = [__v_6];
-        record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+      4u64 => {
+        let __v_6: G = G::from_u64(0);
+        let __v_7: G = { let __values: [G; 3] = [__v_6, __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_388] = { let __args: [G; IN_388] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[388].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_388] = unsafe { *(result.output.as_ptr() as *const [G; OUT_388]) }; __ret } else { aiur_fn_388(__args, record, io_buffer, __cu)? } };
+        let __v_8: G = __r_arr[0];
+        let __v_9: G = G::from_u64(5);
+        let __v_10: G = G::from_u64(0);
+        let __v_11: G = { let __values: [G; 4] = [__v_9, __v_3, __v_8, __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_389] = [__v_11];
+        record.function_queries[389].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      _ => {
-        let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } };
+      5u64 => {
+        let __r_arr: [G; OUT_390] = { let __args: [G; IN_390] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[390].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_390] = unsafe { *(result.output.as_ptr() as *const [G; OUT_390]) }; __ret } else { aiur_fn_390(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } };
+        let __v_7: G = G::from_u64(0);
+        let __v_8: G = { let __values: [G; 3] = [__v_7, __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_390] = { let __args: [G; IN_390] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[390].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_390] = unsafe { *(result.output.as_ptr() as *const [G; OUT_390]) }; __ret } else { aiur_fn_390(__args, record, io_buffer, __cu)? } };
+        let __v_9: G = __r_arr[0];
+        let __v_10: G = G::from_u64(1);
+        let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[303].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_303] = unsafe { *(result.output.as_ptr() as *const [G; OUT_303]) }; __ret } else { aiur_fn_303(__args, record, io_buffer, __cu)? } };
+        let __v_11: G = __r_arr[0];
+        let __v_12: G = G::from_u64(0);
+        let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_12, __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_389] = [__v_13];
+        record.function_queries[389].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      6u64 => {
+        let __v_6: G = G::from_u64(0);
+        let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_5, __v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[331].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_331] = unsafe { *(result.output.as_ptr() as *const [G; OUT_331]) }; __ret } else { aiur_fn_331(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_402] = { let __args: [G; IN_402] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[402].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_402] = unsafe { *(result.output.as_ptr() as *const [G; OUT_402]) }; __ret } else { aiur_fn_402(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[388].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_388] = unsafe { *(result.output.as_ptr() as *const [G; OUT_388]) }; __ret } else { aiur_fn_388(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_2, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[412].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_412] = unsafe { *(result.output.as_ptr() as *const [G; OUT_412]) }; __ret } else { aiur_fn_412(__args, record, io_buffer, __cu)? } };
-        let __v_9: G = __r_arr[0];
-        let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_0, __v_1, __v_9, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } };
-        let __v_10: G = __r_arr[0];
-        let __ret: [G; OUT_481] = [__v_10];
-        record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_389] = [__v_8];
+        record.function_queries[389].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
+      7u64 => {
+        match __v_3.as_canonical_u64() {
+          0u64 => {
+            let __v_6: G = G::from_u64(2);
+            let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[345].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_345] = unsafe { *(result.output.as_ptr() as *const [G; OUT_345]) }; __ret } else { aiur_fn_345(__args, record, io_buffer, __cu)? } };
+            let __v_7: G = __r_arr[0];
+            let __v_8: G = G::from_u64(1);
+            let __v_9: G = G::from_u64(1);
+            let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __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 = G::from_u64(0);
+            let __v_12: G = { let __values: [G; 4] = [__v_6, __v_7, __v_10, __v_11]; 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_389] = [__v_12];
+            record.function_queries[389].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          1u64 => {
+            let __v_6: G = G::from_u64(2);
+            let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { 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_7: G = __r_arr[0];
+            let __v_8: G = G::from_u64(1);
+            let __v_9: G = G::from_u64(1);
+            let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __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 = G::from_u64(0);
+            let __v_12: G = { let __values: [G; 4] = [__v_6, __v_7, __v_10, __v_11]; 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_389] = [__v_12];
+            record.function_queries[389].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
+          },
+        }
+      },
+      8u64 => {
+        let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[388].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_388] = unsafe { *(result.output.as_ptr() as *const [G; OUT_388]) }; __ret } else { aiur_fn_388(__args, record, io_buffer, __cu)? } };
+        let __v_6: G = __r_arr[0];
+        let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = unsafe { *(result.output.as_ptr() as *const [G; OUT_377]) }; __ret } else { aiur_fn_377(__args, record, io_buffer, __cu)? } };
+        let __v_7: G = __r_arr[0];
+        let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[106].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_106] = unsafe { *(result.output.as_ptr() as *const [G; OUT_106]) }; __ret } else { aiur_fn_106(__args, record, io_buffer, __cu)? } };
+        let __v_8: G = __r_arr[0];
+        let __v_9: G = __r_arr[1];
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).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_10: G = __loaded[0];
+        let __v_11: G = __loaded[1];
+        let __v_12: G = __loaded[2];
+        let __v_13: G = __loaded[3];
+        match __v_10.as_canonical_u64() {
+          2u64 => {
+            let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[258].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_258] = unsafe { *(result.output.as_ptr() as *const [G; OUT_258]) }; __ret } else { aiur_fn_258(__args, record, io_buffer, __cu)? } };
+            let __v_14: G = __r_arr[0];
+            let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+            let __v_15: G = __loaded[0];
+            let __v_16: G = __loaded[1];
+            let __v_17: G = __loaded[2];
+            let __v_18: G = __loaded[3];
+            let __v_19: G = __loaded[4];
+            let __v_20: G = __loaded[5];
+            let __v_21: G = __loaded[6];
+            let __v_22: G = __loaded[7];
+            let __v_23: G = __loaded[8];
+            let __v_24: G = __loaded[9];
+            let __v_25: G = __loaded[10];
+            let __v_26: G = __loaded[11];
+            if (__v_11 != __v_3) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: Some("projection's structure type differs from the value's head".to_string()) });
+            }
+            match __v_15.as_canonical_u64() {
+              5u64 => {
+                let __v_27: G = G::from_u64(0);
+                let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_22, __v_23, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[261].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_261] = unsafe { *(result.output.as_ptr() as *const [G; OUT_261]) }; __ret } else { aiur_fn_261(__args, record, io_buffer, __cu)? } };
+                let __v_28: G = __r_arr[0];
+                let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_28.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+                let __v_29: G = __loaded[0];
+                let __v_30: G = __loaded[1];
+                let __v_31: G = __loaded[2];
+                let __v_32: G = __loaded[3];
+                let __v_33: G = __loaded[4];
+                let __v_34: G = __loaded[5];
+                let __v_35: G = __loaded[6];
+                let __v_36: G = __loaded[7];
+                let __v_37: G = __loaded[8];
+                let __v_38: G = __loaded[9];
+                let __v_39: G = __loaded[10];
+                let __v_40: G = __loaded[11];
+                let __v_41: G = G::from_u64(1);
+                if (__v_20 != __v_41) {
+                  return Err(ExecError::AssertEqMismatch { lhs: __v_20.as_canonical_u64(), rhs: __v_41.as_canonical_u64(), msg: Some("projection on an inductive with more than one constructor".to_string()) });
+                }
+                match __v_29.as_canonical_u64() {
+                  6u64 => {
+                    let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_31, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } else { aiur_fn_307(__args, record, io_buffer, __cu)? } };
+                    let __v_42: G = __r_arr[0];
+                    let __r_arr: [G; OUT_391] = { let __args: [G; IN_391] = [__v_42, __v_9, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[391].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_391] = unsafe { *(result.output.as_ptr() as *const [G; OUT_391]) }; __ret } else { aiur_fn_391(__args, record, io_buffer, __cu)? } };
+                    let __v_43: G = __r_arr[0];
+                    let __v_44: G = G::from_u64(0);
+                    let __r_arr: [G; OUT_392] = { let __args: [G; IN_392] = [__v_43, __v_4, __v_44, __v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[392].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_392] = unsafe { *(result.output.as_ptr() as *const [G; OUT_392]) }; __ret } else { aiur_fn_392(__args, record, io_buffer, __cu)? } };
+                    let __v_45: G = __r_arr[0];
+                    let __ret: [G; OUT_389] = [__v_45];
+                    record.function_queries[389].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
+                  },
+                  _ => {
+                    return Err(ExecError::MatchNoCase(__v_29.as_canonical_u64()));
+                  },
+                }
+              },
+              _ => {
+                return Err(ExecError::MatchNoCase(__v_15.as_canonical_u64()));
+              },
+            }
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64()));
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
     }
   })
 }
 
-const INPUT_SIZE_482: usize = 5;
-const IN_482: usize = 5;
-const OUT_482: usize = 1;
-fn aiur_fn_482(
-  inp: [G; IN_482],
+const INPUT_SIZE_390: usize = 2;
+const IN_390: usize = 2;
+const OUT_390: usize = 1;
+fn aiur_fn_390(
+  inp: [G; IN_390],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_482], ExecError> {
+) -> Result<[G; OUT_390], 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 = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_1.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() {
+    let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[388].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_388] = unsafe { *(result.output.as_ptr() as *const [G; OUT_388]) }; __ret } else { aiur_fn_388(__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];
+    let __v_4: G = __loaded[1];
+    let __v_5: G = __loaded[2];
+    let __v_6: G = __loaded[3];
+    match __v_3.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_0, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } else { aiur_fn_483(__args, record, io_buffer, __cu)? } };
-        let __v_6: G = __r_arr[0];
-        let __ret: [G; OUT_482] = [__v_6];
-        record.function_queries[482].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_1, __v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } else { aiur_fn_483(__args, record, io_buffer, __cu)? } };
-        let __v_6: G = __r_arr[0];
-        let __ret: [G; OUT_482] = [__v_6];
-        record.function_queries[482].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_390] = [__v_4];
+        record.function_queries[390].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
+        let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = unsafe { *(result.output.as_ptr() as *const [G; OUT_377]) }; __ret } else { aiur_fn_377(__args, record, io_buffer, __cu)? } };
+        let __v_7: 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_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: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].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];
+        match __v_8.as_canonical_u64() {
+          1u64 => {
+            let __ret: [G; OUT_390] = [__v_9];
+            record.function_queries[390].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64()));
+          },
+        }
       },
     }
   })
 }
 
-const INPUT_SIZE_483: usize = 5;
-const IN_483: usize = 5;
-const OUT_483: usize = 1;
-fn aiur_fn_483(
-  inp: [G; IN_483],
+const INPUT_SIZE_391: usize = 3;
+const IN_391: usize = 3;
+const OUT_391: usize = 1;
+fn aiur_fn_391(
+  inp: [G; IN_391],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_483], ExecError> {
+) -> Result<[G; OUT_391], 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_499] = { let __args: [G; IN_499] = [__v_0, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } else { aiur_fn_499(__args, record, io_buffer, __cu)? } };
-    let __v_5: G = __r_arr[0];
-    match __v_5.as_canonical_u64() {
-      1u64 => {
-        let __v_6: G = G::from_u64(1);
-        let __ret: [G; OUT_483] = [__v_6];
-        record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    match __v_2.as_canonical_u64() {
+      0u64 => {
+        let __ret: [G; OUT_391] = [__v_0];
+        record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_0, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[489].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_489] = unsafe { *(result.output.as_ptr() as *const [G; OUT_489]) }; __ret } else { aiur_fn_489(__args, record, io_buffer, __cu)? } };
-        let __v_6: G = __r_arr[0];
-        match __v_6.as_canonical_u64() {
-          1u64 => {
-            let __v_7: G = G::from_u64(1);
-            let __ret: [G; OUT_483] = [__v_7];
-            record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          0u64 => {
-            let __r_arr: [G; OUT_433] = { let __args: [G; IN_433] = [__v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[433].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_433] = unsafe { *(result.output.as_ptr() as *const [G; OUT_433]) }; __ret } else { aiur_fn_433(__args, record, io_buffer, __cu)? } };
-            let __v_7: G = __r_arr[0];
-            let __r_arr: [G; OUT_433] = { let __args: [G; IN_433] = [__v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[433].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_433] = unsafe { *(result.output.as_ptr() as *const [G; OUT_433]) }; __ret } else { aiur_fn_433(__args, record, io_buffer, __cu)? } };
-            let __v_8: G = __r_arr[0];
-            let __v_9: G = (__v_7 - __v_8);
-            match __v_9.as_canonical_u64() {
+      _ => {
+        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_3: G = __loaded[0];
+        let __v_4: G = __loaded[1];
+        let __v_5: G = __loaded[2];
+        let __v_6: G = __loaded[3];
+        match __v_3.as_canonical_u64() {
+          5u64 => {
+            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_7: G = __loaded[0];
+            let __v_8: G = __loaded[1];
+            let __v_9: G = __loaded[2];
+            match __v_7.as_canonical_u64() {
               0u64 => {
-                let __v_10: G = G::from_u64(1);
-                let __ret: [G; OUT_483] = [__v_10];
-                record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __v_10: G = G::from_u64(0);
+                let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_5, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[331].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_331] = unsafe { *(result.output.as_ptr() as *const [G; OUT_331]) }; __ret } else { aiur_fn_331(__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_2 - __v_12);
+                let __r_arr: [G; OUT_391] = { let __args: [G; IN_391] = [__v_11, __v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[391].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_391] = unsafe { *(result.output.as_ptr() as *const [G; OUT_391]) }; __ret } else { aiur_fn_391(__args, record, io_buffer, __cu)? } };
+                let __v_14: G = __r_arr[0];
+                let __ret: [G; OUT_391] = [__v_14];
+                record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_7, __v_8, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } else { aiur_fn_484(__args, record, io_buffer, __cu)? } };
-                let __v_10: G = __r_arr[0];
-                match __v_10.as_canonical_u64() {
-                  1u64 => {
-                    let __v_11: G = G::from_u64(1);
-                    let __ret: [G; OUT_483] = [__v_11];
-                    record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
-                  0u64 => {
-                    let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_7, __v_8, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } else { aiur_fn_499(__args, record, io_buffer, __cu)? } };
-                    let __v_11: G = __r_arr[0];
-                    match __v_11.as_canonical_u64() {
-                      1u64 => {
-                        let __v_12: G = G::from_u64(1);
-                        let __ret: [G; OUT_483] = [__v_12];
-                        record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                        return Ok(__ret);
-                      },
-                      0u64 => {
-                        let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } };
-                        let __v_12: G = __r_arr[0];
-                        let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } };
-                        let __v_13: G = __r_arr[0];
-                        let __v_14: G = (__v_12 - __v_13);
-                        match __v_14.as_canonical_u64() {
-                          0u64 => {
-                            let __v_15: G = G::from_u64(1);
-                            let __ret: [G; OUT_483] = [__v_15];
-                            record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                            return Ok(__ret);
-                          },
-                          _ => {
-                            let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = [__v_12, __v_13, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } else { aiur_fn_485(__args, record, io_buffer, __cu)? } };
-                            let __v_15: G = __r_arr[0];
-                            match __v_15.as_canonical_u64() {
-                              1u64 => {
-                                let __v_16: G = G::from_u64(1);
-                                let __ret: [G; OUT_483] = [__v_16];
-                                record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                return Ok(__ret);
-                              },
-                              0u64 => {
-                                let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_12, __v_13, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } };
-                                let __v_16: G = __r_arr[0];
-                                match __v_16.as_canonical_u64() {
-                                  1u64 => {
-                                    let __v_17: G = G::from_u64(1);
-                                    let __ret: [G; OUT_483] = [__v_17];
-                                    record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                    return Ok(__ret);
-                                  },
-                                  0u64 => {
-                                    let __r_arr: [G; OUT_494] = { let __args: [G; IN_494] = [__v_12, __v_13, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[494].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_494] = unsafe { *(result.output.as_ptr() as *const [G; OUT_494]) }; __ret } else { aiur_fn_494(__args, record, io_buffer, __cu)? } };
-                                    let __v_17: G = __r_arr[0];
-                                    match __v_17.as_canonical_u64() {
-                                      1u64 => {
-                                        let __v_18: G = G::from_u64(1);
-                                        let __ret: [G; OUT_483] = [__v_18];
-                                        record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                        return Ok(__ret);
-                                      },
-                                      0u64 => {
-                                        let __r_arr: [G; OUT_494] = { let __args: [G; IN_494] = [__v_13, __v_12, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[494].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_494] = unsafe { *(result.output.as_ptr() as *const [G; OUT_494]) }; __ret } else { aiur_fn_494(__args, record, io_buffer, __cu)? } };
-                                        let __v_18: G = __r_arr[0];
-                                        match __v_18.as_canonical_u64() {
-                                          1u64 => {
-                                            let __v_19: G = G::from_u64(1);
-                                            let __ret: [G; OUT_483] = [__v_19];
-                                            record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                            return Ok(__ret);
-                                          },
-                                          0u64 => {
-                                            let __r_arr: [G; OUT_493] = { let __args: [G; IN_493] = [__v_12, __v_13, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[493].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_493] = unsafe { *(result.output.as_ptr() as *const [G; OUT_493]) }; __ret } else { aiur_fn_493(__args, record, io_buffer, __cu)? } };
-                                            let __v_19: G = __r_arr[0];
-                                            let __v_20: G = __r_arr[1];
-                                            match __v_19.as_canonical_u64() {
-                                              1u64 => {
-                                                let __ret: [G; OUT_483] = [__v_20];
-                                                record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                                return Ok(__ret);
-                                              },
-                                              0u64 => {
-                                                let __v_21: G = G::from_u64(16);
-                                                let __r_arr: [G; OUT_505] = { let __args: [G; IN_505] = [__v_12, __v_13, __v_21, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[505].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_505] = unsafe { *(result.output.as_ptr() as *const [G; OUT_505]) }; __ret } else { aiur_fn_505(__args, record, io_buffer, __cu)? } };
-                                                let __v_22: G = __r_arr[0];
-                                                let __v_23: G = __r_arr[1];
-                                                match __v_22.as_canonical_u64() {
-                                                  1u64 => {
-                                                    let __ret: [G; OUT_483] = [__v_23];
-                                                    record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                                    return Ok(__ret);
-                                                  },
-                                                  0u64 => {
-                                                    let __r_arr: [G; OUT_496] = { let __args: [G; IN_496] = [__v_12, __v_13, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[496].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_496] = unsafe { *(result.output.as_ptr() as *const [G; OUT_496]) }; __ret } else { aiur_fn_496(__args, record, io_buffer, __cu)? } };
-                                                    let __v_24: G = __r_arr[0];
-                                                    let __ret: [G; OUT_483] = [__v_24];
-                                                    record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                                    return Ok(__ret);
-                                                  },
-                                                  _ => {
-                                                    return Err(ExecError::MatchNoCase(__v_22.as_canonical_u64()));
-                                                  },
-                                                }
-                                              },
-                                              _ => {
-                                                return Err(ExecError::MatchNoCase(__v_19.as_canonical_u64()));
-                                              },
-                                            }
-                                          },
-                                          _ => {
-                                            return Err(ExecError::MatchNoCase(__v_18.as_canonical_u64()));
-                                          },
-                                        }
-                                      },
-                                      _ => {
-                                        return Err(ExecError::MatchNoCase(__v_17.as_canonical_u64()));
-                                      },
-                                    }
-                                  },
-                                  _ => {
-                                    return Err(ExecError::MatchNoCase(__v_16.as_canonical_u64()));
-                                  },
-                                }
-                              },
-                              _ => {
-                                return Err(ExecError::MatchNoCase(__v_15.as_canonical_u64()));
-                              },
-                            }
-                          },
-                        }
-                      },
-                      _ => {
-                        return Err(ExecError::MatchNoCase(__v_11.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_6.as_canonical_u64()));
+            return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
-      },
     }
   })
 }
 
-const INPUT_SIZE_484: usize = 5;
-const IN_484: usize = 5;
-const OUT_484: usize = 1;
-fn aiur_fn_484(
-  inp: [G; IN_484],
+const INPUT_SIZE_392: usize = 5;
+const IN_392: usize = 5;
+const OUT_392: usize = 1;
+fn aiur_fn_392(
+  inp: [G; IN_392],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_484], ExecError> {
+) -> Result<[G; OUT_392], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -43172,2549 +34720,2168 @@ fn aiur_fn_484(
     let __v_7: G = __loaded[2];
     let __v_8: G = __loaded[3];
     match __v_5.as_canonical_u64() {
-      1u64 => {
-        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_9: G = __loaded[0];
-        let __v_10: G = __loaded[1];
-        let __v_11: G = __loaded[2];
-        let __v_12: G = __loaded[3];
+      5u64 => {
+        let __v_9: G = (__v_1 - __v_2);
         match __v_9.as_canonical_u64() {
-          1u64 => {
-            let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_6, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[216].get_mut(&__args[..]) { 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_13: G = __r_arr[0];
-            let __ret: [G; OUT_484] = [__v_13];
-            record.function_queries[484].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+          0u64 => {
+            let __ret: [G; OUT_392] = [__v_6];
+            record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __v_13: G = G::from_u64(0);
-            let __ret: [G; OUT_484] = [__v_13];
-            record.function_queries[484].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __v_10: G = G::from_u64(8);
+            let __v_11: G = { let __values: [G; 4] = [__v_10, __v_3, __v_2, __v_4]; 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_12: G = G::from_u64(0);
+            let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_7, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[331].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_331] = unsafe { *(result.output.as_ptr() as *const [G; OUT_331]) }; __ret } else { aiur_fn_331(__args, record, io_buffer, __cu)? } };
+            let __v_13: G = __r_arr[0];
+            let __v_14: G = G::from_u64(1);
+            let __v_15: G = (__v_2 + __v_14);
+            let __r_arr: [G; OUT_392] = { let __args: [G; IN_392] = [__v_13, __v_1, __v_15, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[392].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_392] = unsafe { *(result.output.as_ptr() as *const [G; OUT_392]) }; __ret } else { aiur_fn_392(__args, record, io_buffer, __cu)? } };
+            let __v_16: G = __r_arr[0];
+            let __ret: [G; OUT_392] = [__v_16];
+            record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
-      4u64 => {
-        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_9: G = __loaded[0];
-        let __v_10: G = __loaded[1];
-        let __v_11: G = __loaded[2];
-        let __v_12: G = __loaded[3];
-        match __v_9.as_canonical_u64() {
-          4u64 => {
-            let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_6, __v_10, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } };
-            let __v_13: G = __r_arr[0];
-            match __v_13.as_canonical_u64() {
-              1u64 => {
-                let __v_14: G = G::from_u64(0);
-                let __v_15: G = { let __values: [G; 3] = [__v_14, __v_6, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_481] = { let __args: [G; IN_481] = [__v_7, __v_11, __v_15, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } };
-                let __v_16: G = __r_arr[0];
-                let __ret: [G; OUT_484] = [__v_16];
-                record.function_queries[484].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              0u64 => {
-                let __v_14: G = G::from_u64(0);
-                let __ret: [G; OUT_484] = [__v_14];
-                record.function_queries[484].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              _ => {
-                return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64()));
-              },
-            }
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_393: usize = 2;
+const IN_393: usize = 2;
+const OUT_393: usize = 1;
+fn aiur_fn_393(
+  inp: [G; IN_393],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_393], 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 __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_5: G = __loaded[0];
+        let __v_6: G = __loaded[1];
+        let __v_7: G = __loaded[2];
+        match __v_5.as_canonical_u64() {
+          1u64 => {
+            let __v_8: G = G::from_u64(1);
+            let __ret: [G; OUT_393] = [__v_8];
+            record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
           },
           _ => {
-            let __v_13: G = G::from_u64(0);
-            let __ret: [G; OUT_484] = [__v_13];
-            record.function_queries[484].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __v_8: G = G::from_u64(0);
+            let __ret: [G; OUT_393] = [__v_8];
+            record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
-      5u64 => {
-        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_9: G = __loaded[0];
-        let __v_10: G = __loaded[1];
-        let __v_11: G = __loaded[2];
-        let __v_12: G = __loaded[3];
-        match __v_9.as_canonical_u64() {
-          5u64 => {
-            let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_6, __v_10, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } };
-            let __v_13: G = __r_arr[0];
-            match __v_13.as_canonical_u64() {
-              1u64 => {
-                let __v_14: G = G::from_u64(0);
-                let __v_15: G = { let __values: [G; 3] = [__v_14, __v_6, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_481] = { let __args: [G; IN_481] = [__v_7, __v_11, __v_15, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } };
-                let __v_16: G = __r_arr[0];
-                let __ret: [G; OUT_484] = [__v_16];
-                record.function_queries[484].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_5: G = __loaded[0];
+        let __v_6: G = __loaded[1];
+        let __v_7: G = __loaded[2];
+        match __v_5.as_canonical_u64() {
+          1u64 => {
+            let __v_8: G = G::from_u64(0);
+            let __ret: [G; OUT_393] = [__v_8];
+            record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          0u64 => {
+            let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } else { aiur_fn_295(__args, record, io_buffer, __cu)? } };
+            let __v_8: G = __r_arr[0];
+            match __v_8.as_canonical_u64() {
               0u64 => {
-                let __v_14: G = G::from_u64(0);
-                let __ret: [G; OUT_484] = [__v_14];
-                record.function_queries[484].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __v_9: G = G::from_u64(0);
+                let __ret: [G; OUT_393] = [__v_9];
+                record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64()));
+                let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[393].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_393] = unsafe { *(result.output.as_ptr() as *const [G; OUT_393]) }; __ret } else { aiur_fn_393(__args, record, io_buffer, __cu)? } };
+                let __v_9: G = __r_arr[0];
+                let __ret: [G; OUT_393] = [__v_9];
+                record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
               },
             }
           },
           _ => {
-            let __v_13: G = G::from_u64(0);
-            let __ret: [G; OUT_484] = [__v_13];
-            record.function_queries[484].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
+            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
           },
         }
       },
       _ => {
-        let __v_9: G = G::from_u64(0);
-        let __ret: [G; OUT_484] = [__v_9];
-        record.function_queries[484].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_485: usize = 5;
-const IN_485: usize = 5;
-const OUT_485: usize = 1;
-fn aiur_fn_485(
-  inp: [G; IN_485],
+const INPUT_SIZE_394: usize = 3;
+const IN_394: usize = 3;
+const OUT_394: usize = 1;
+fn aiur_fn_394(
+  inp: [G; IN_394],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_485], ExecError> {
+) -> Result<[G; OUT_394], 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_467] = { let __args: [G; IN_467] = [__v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[467].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_467] = unsafe { *(result.output.as_ptr() as *const [G; OUT_467]) }; __ret } else { aiur_fn_467(__args, record, io_buffer, __cu)? } };
-    let __v_5: G = __r_arr[0];
-    let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_5, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } };
-    let __v_6: G = __r_arr[0];
-    match __v_6.as_canonical_u64() {
+    let __v_3: G = (__v_0 - __v_1);
+    match __v_3.as_canonical_u64() {
       0u64 => {
-        let __v_7: G = G::from_u64(0);
-        let __ret: [G; OUT_485] = [__v_7];
-        record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __v_4: G = G::from_u64(1);
+        let __ret: [G; OUT_394] = [__v_4];
+        record.function_queries[394].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      1u64 => {
-        let __r_arr: [G; OUT_467] = { let __args: [G; IN_467] = [__v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[467].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_467] = unsafe { *(result.output.as_ptr() as *const [G; OUT_467]) }; __ret } else { aiur_fn_467(__args, record, io_buffer, __cu)? } };
+      _ => {
+        let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } };
+        let __v_4: G = __r_arr[0];
+        let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } };
+        let __v_5: G = __r_arr[0];
+        let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } else { aiur_fn_314(__args, record, io_buffer, __cu)? } };
+        let __v_6: G = __r_arr[0];
+        let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } else { aiur_fn_324(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_5, __v_7, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_0, __v_1, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[395].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_395] = unsafe { *(result.output.as_ptr() as *const [G; OUT_395]) }; __ret } else { aiur_fn_395(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
-        let __ret: [G; OUT_485] = [__v_8];
-        record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_394] = [__v_8];
+        record.function_queries[394].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64()));
-      },
     }
   })
 }
 
-const INPUT_SIZE_486: usize = 4;
-const IN_486: usize = 4;
-const OUT_486: usize = 1;
-fn aiur_fn_486(
-  inp: [G; IN_486],
+const INPUT_SIZE_395: usize = 3;
+const IN_395: usize = 3;
+const OUT_395: usize = 1;
+fn aiur_fn_395(
+  inp: [G; IN_395],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_486], ExecError> {
+) -> Result<[G; OUT_395], 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_467] = { let __args: [G; IN_467] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[467].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_467] = unsafe { *(result.output.as_ptr() as *const [G; OUT_467]) }; __ret } else { aiur_fn_467(__args, record, io_buffer, __cu)? } };
-    let __v_4: G = __r_arr[0];
-    let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_4, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } };
-    let __v_5: 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_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: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].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];
-    match __v_6.as_canonical_u64() {
+    let __v_3: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_1.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_3.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_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_10: G = __loaded[0];
-        let __v_11: G = __loaded[1];
-        let __v_12: G = __loaded[2];
-        match __v_10.as_canonical_u64() {
-          0u64 => {
-            let __v_13: G = G::from_u64(1);
-            let __ret: [G; OUT_486] = [__v_13];
-            record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            let __v_13: G = G::from_u64(0);
-            let __ret: [G; OUT_486] = [__v_13];
-            record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-        }
+        let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = unsafe { *(result.output.as_ptr() as *const [G; OUT_396]) }; __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } };
+        let __v_4: G = __r_arr[0];
+        let __ret: [G; OUT_395] = [__v_4];
+        record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
       _ => {
-        let __v_10: G = G::from_u64(0);
-        let __ret: [G; OUT_486] = [__v_10];
-        record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = unsafe { *(result.output.as_ptr() as *const [G; OUT_396]) }; __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } };
+        let __v_4: G = __r_arr[0];
+        let __ret: [G; OUT_395] = [__v_4];
+        record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_487: usize = 5;
-const IN_487: usize = 5;
-const OUT_487: usize = 1;
-fn aiur_fn_487(
-  inp: [G; IN_487],
+const INPUT_SIZE_396: usize = 3;
+const IN_396: usize = 3;
+const OUT_396: usize = 1;
+fn aiur_fn_396(
+  inp: [G; IN_396],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_487], ExecError> {
+) -> Result<[G; OUT_396], 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_467] = { let __args: [G; IN_467] = [__v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[467].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_467] = unsafe { *(result.output.as_ptr() as *const [G; OUT_467]) }; __ret } else { aiur_fn_467(__args, record, io_buffer, __cu)? } };
-    let __v_5: G = __r_arr[0];
-    let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_5, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } };
-    let __v_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_6, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[488].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_488] = unsafe { *(result.output.as_ptr() as *const [G; OUT_488]) }; __ret } else { aiur_fn_488(__args, record, io_buffer, __cu)? } };
-    let __v_7: G = __r_arr[0];
-    match __v_7.as_canonical_u64() {
-      0u64 => {
-        let __v_8: G = G::from_u64(0);
-        let __ret: [G; OUT_487] = [__v_8];
-        record.function_queries[487].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
+    let __r_arr: [G; OUT_397] = { let __args: [G; IN_397] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[397].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_397] = unsafe { *(result.output.as_ptr() as *const [G; OUT_397]) }; __ret } else { aiur_fn_397(__args, record, io_buffer, __cu)? } };
+    let __v_3: G = __r_arr[0];
+    match __v_3.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_467] = { let __args: [G; IN_467] = [__v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[467].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_467] = unsafe { *(result.output.as_ptr() as *const [G; OUT_467]) }; __ret } else { aiur_fn_467(__args, record, io_buffer, __cu)? } };
-        let __v_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_5, __v_8, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } };
-        let __v_9: G = __r_arr[0];
-        let __ret: [G; OUT_487] = [__v_9];
-        record.function_queries[487].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __v_4: G = G::from_u64(1);
+        let __ret: [G; OUT_396] = [__v_4];
+        record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64()));
+        let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[404].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_404] = unsafe { *(result.output.as_ptr() as *const [G; OUT_404]) }; __ret } else { aiur_fn_404(__args, record, io_buffer, __cu)? } };
+        let __v_4: G = __r_arr[0];
+        let __ret: [G; OUT_396] = [__v_4];
+        record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_488: usize = 2;
-const IN_488: usize = 2;
-const OUT_488: usize = 1;
-fn aiur_fn_488(
-  inp: [G; IN_488],
+const INPUT_SIZE_397: usize = 3;
+const IN_397: usize = 3;
+const OUT_397: usize = 1;
+fn aiur_fn_397(
+  inp: [G; IN_397],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_488], ExecError> {
+) -> Result<[G; OUT_397], 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_189] = { let __args: [G; IN_189] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[189].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_189] = unsafe { *(result.output.as_ptr() as *const [G; OUT_189]) }; __ret } else { aiur_fn_189(__args, record, io_buffer, __cu)? } };
-    let __v_2: G = __r_arr[0];
-    let __v_3: G = __r_arr[1];
-    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_4: G = __loaded[0];
-    let __v_5: G = __loaded[1];
-    let __v_6: G = __loaded[2];
-    let __v_7: G = __loaded[3];
-    match __v_4.as_canonical_u64() {
+    let __v_2: G = inp[2];
+    let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[106].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_106] = unsafe { *(result.output.as_ptr() as *const [G; OUT_106]) }; __ret } else { aiur_fn_106(__args, record, io_buffer, __cu)? } };
+    let __v_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[106].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_106] = unsafe { *(result.output.as_ptr() as *const [G; OUT_106]) }; __ret } else { aiur_fn_106(__args, record, io_buffer, __cu)? } };
+    let __v_5: G = __r_arr[0];
+    let __v_6: G = __r_arr[1];
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; 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: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].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];
+    match __v_7.as_canonical_u64() {
       2u64 => {
-        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-        let __v_8: G = __r_arr[0];
-        let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].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 __v_17: G = __loaded[8];
-        let __v_18: G = __loaded[9];
-        let __v_19: G = __loaded[10];
-        match __v_9.as_canonical_u64() {
-          5u64 => {
-            let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { 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_20: G = __r_arr[0];
-            match __v_20.as_canonical_u64() {
-              1u64 => {
-                let __v_21: G = G::from_u64(0);
-                let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_14, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-                let __v_22: G = __r_arr[0];
-                let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_1, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-                let __v_23: G = __r_arr[0];
-                let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_23.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr };
-                let __v_24: G = __loaded[0];
-                let __v_25: G = __loaded[1];
-                let __v_26: G = __loaded[2];
-                let __v_27: G = __loaded[3];
-                let __v_28: G = __loaded[4];
-                let __v_29: G = __loaded[5];
-                let __v_30: G = __loaded[6];
-                let __v_31: G = __loaded[7];
-                let __v_32: G = __loaded[8];
-                let __v_33: G = __loaded[9];
-                let __v_34: G = __loaded[10];
-                match __v_24.as_canonical_u64() {
-                  6u64 => {
-                    match __v_30.as_canonical_u64() {
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; 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: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].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];
+        match __v_11.as_canonical_u64() {
+          2u64 => {
+            let __v_15: G = (__v_8 - __v_12);
+            match __v_15.as_canonical_u64() {
+              0u64 => {
+                let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[393].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_393] = unsafe { *(result.output.as_ptr() as *const [G; OUT_393]) }; __ret } else { aiur_fn_393(__args, record, io_buffer, __cu)? } };
+                let __v_16: G = __r_arr[0];
+                match __v_16.as_canonical_u64() {
+                  0u64 => {
+                    let __v_17: G = G::from_u64(0);
+                    let __ret: [G; OUT_397] = [__v_17];
+                    record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
+                  },
+                  _ => {
+                    let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } else { aiur_fn_711(__args, record, io_buffer, __cu)? } };
+                    let __v_17: G = __r_arr[0];
+                    let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } else { aiur_fn_711(__args, record, io_buffer, __cu)? } };
+                    let __v_18: G = __r_arr[0];
+                    let __v_19: G = (__v_17 - __v_18);
+                    match __v_19.as_canonical_u64() {
                       0u64 => {
-                        let __v_35: G = G::from_u64(1);
-                        let __ret: [G; OUT_488] = [__v_35];
-                        record.function_queries[488].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_4, __v_6, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[398].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_398] = unsafe { *(result.output.as_ptr() as *const [G; OUT_398]) }; __ret } else { aiur_fn_398(__args, record, io_buffer, __cu)? } };
+                        let __v_20: G = __r_arr[0];
+                        let __ret: [G; OUT_397] = [__v_20];
+                        record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       _ => {
-                        let __v_35: G = G::from_u64(0);
-                        let __ret: [G; OUT_488] = [__v_35];
-                        record.function_queries[488].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __v_20: G = G::from_u64(0);
+                        let __ret: [G; OUT_397] = [__v_20];
+                        record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                     }
                   },
-                  _ => {
-                    let __v_35: G = G::from_u64(0);
-                    let __ret: [G; OUT_488] = [__v_35];
-                    record.function_queries[488].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
                 }
               },
               _ => {
-                let __v_21: G = G::from_u64(0);
-                let __ret: [G; OUT_488] = [__v_21];
-                record.function_queries[488].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __v_16: G = G::from_u64(0);
+                let __ret: [G; OUT_397] = [__v_16];
+                record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
           _ => {
-            let __v_20: G = G::from_u64(0);
-            let __ret: [G; OUT_488] = [__v_20];
-            record.function_queries[488].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __v_15: G = G::from_u64(0);
+            let __ret: [G; OUT_397] = [__v_15];
+            record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
       _ => {
-        let __v_8: G = G::from_u64(0);
-        let __ret: [G; OUT_488] = [__v_8];
-        record.function_queries[488].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __v_11: G = G::from_u64(0);
+        let __ret: [G; OUT_397] = [__v_11];
+        record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_489: usize = 5;
-const IN_489: usize = 5;
-const OUT_489: usize = 1;
-fn aiur_fn_489(
-  inp: [G; IN_489],
+const INPUT_SIZE_398: usize = 3;
+const IN_398: usize = 3;
+const OUT_398: usize = 1;
+fn aiur_fn_398(
+  inp: [G; IN_398],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_489], ExecError> {
+) -> Result<[G; OUT_398], 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_490] = { let __args: [G; IN_490] = [__v_0, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[490].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_490] = unsafe { *(result.output.as_ptr() as *const [G; OUT_490]) }; __ret } else { aiur_fn_490(__args, record, io_buffer, __cu)? } };
-    let __v_5: G = __r_arr[0];
-    match __v_5.as_canonical_u64() {
+    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 __ret: [G; OUT_489] = [__v_6];
-        record.function_queries[489].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_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() {
+          1u64 => {
+            let __v_9: G = G::from_u64(1);
+            let __ret: [G; OUT_398] = [__v_9];
+            record.function_queries[398].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            let __v_9: G = G::from_u64(0);
+            let __ret: [G; OUT_398] = [__v_9];
+            record.function_queries[398].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+        }
       },
       0u64 => {
-        let __r_arr: [G; OUT_490] = { let __args: [G; IN_490] = [__v_1, __v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[490].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_490] = unsafe { *(result.output.as_ptr() as *const [G; OUT_490]) }; __ret } else { aiur_fn_490(__args, record, io_buffer, __cu)? } };
-        let __v_6: G = __r_arr[0];
-        let __ret: [G; OUT_489] = [__v_6];
-        record.function_queries[489].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_490: usize = 5;
-const IN_490: usize = 5;
-const OUT_490: usize = 1;
-fn aiur_fn_490(
-  inp: [G; IN_490],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_490], 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 __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_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() {
-      7u64 => {
+        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() {
           1u64 => {
-            let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_7, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[393].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_393] = unsafe { *(result.output.as_ptr() as *const [G; OUT_393]) }; __ret } else { aiur_fn_393(__args, record, io_buffer, __cu)? } };
+            let __v_9: G = G::from_u64(0);
+            let __ret: [G; OUT_398] = [__v_9];
+            record.function_queries[398].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          0u64 => {
+            let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_4, __v_7, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
-            let __v_10: G = __r_arr[1];
             match __v_9.as_canonical_u64() {
-              1u64 => {
-                let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_10, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[395].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_395] = unsafe { *(result.output.as_ptr() as *const [G; OUT_395]) }; __ret } else { aiur_fn_395(__args, record, io_buffer, __cu)? } };
-                let __v_11: G = __r_arr[0];
-                let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_11, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } };
-                let __v_12: G = __r_arr[0];
-                let __ret: [G; OUT_490] = [__v_12];
-                record.function_queries[490].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
               0u64 => {
-                let __v_11: G = G::from_u64(0);
-                let __ret: [G; OUT_490] = [__v_11];
-                record.function_queries[490].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __v_10: G = G::from_u64(0);
+                let __ret: [G; OUT_398] = [__v_10];
+                record.function_queries[398].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64()));
+                let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[398].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_398] = unsafe { *(result.output.as_ptr() as *const [G; OUT_398]) }; __ret } else { aiur_fn_398(__args, record, io_buffer, __cu)? } };
+                let __v_10: G = __r_arr[0];
+                let __ret: [G; OUT_398] = [__v_10];
+                record.function_queries[398].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
               },
             }
           },
           _ => {
-            let __v_9: G = G::from_u64(0);
-            let __ret: [G; OUT_490] = [__v_9];
-            record.function_queries[490].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
+            return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64()));
           },
         }
       },
       _ => {
-        let __v_9: G = G::from_u64(0);
-        let __ret: [G; OUT_490] = [__v_9];
-        record.function_queries[490].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
+        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_491: usize = 2;
-const IN_491: usize = 2;
-const OUT_491: usize = 1;
-fn aiur_fn_491(
-  inp: [G; IN_491],
+const INPUT_SIZE_399: usize = 1;
+const IN_399: usize = 1;
+const OUT_399: usize = 1;
+fn aiur_fn_399(
+  inp: [G; IN_399],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_491], ExecError> {
+) -> Result<[G; OUT_399], 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() {
+    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() {
       7u64 => {
-        match __v_3.as_canonical_u64() {
+        match __v_2.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } else { aiur_fn_320(__args, record, io_buffer, __cu)? } };
-            let __v_6: G = __r_arr[0];
-            let __ret: [G; OUT_491] = [__v_6];
-            record.function_queries[491].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { 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_5: G = __r_arr[0];
+            let __ret: [G; OUT_399] = [__v_5];
+            record.function_queries[399].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __v_6: G = G::from_u64(0);
-            let __ret: [G; OUT_491] = [__v_6];
-            record.function_queries[491].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __v_5: G = G::from_u64(0);
+            let __ret: [G; OUT_399] = [__v_5];
+            record.function_queries[399].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
       2u64 => {
-        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[138].get_mut(&__args[..]) { 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_5: G = __r_arr[0];
+        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } else { aiur_fn_272(__args, record, io_buffer, __cu)? } };
-        let __v_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_8: G = __r_arr[0];
-        let __ret: [G; OUT_491] = [__v_8];
-        record.function_queries[491].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_399] = [__v_6];
+        record.function_queries[399].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __v_6: G = G::from_u64(0);
-        let __ret: [G; OUT_491] = [__v_6];
-        record.function_queries[491].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __v_5: G = G::from_u64(0);
+        let __ret: [G; OUT_399] = [__v_5];
+        record.function_queries[399].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_492: usize = 2;
-const IN_492: usize = 2;
-const OUT_492: usize = 3;
-fn aiur_fn_492(
-  inp: [G; IN_492],
+const INPUT_SIZE_400: usize = 1;
+const IN_400: usize = 1;
+const OUT_400: usize = 3;
+fn aiur_fn_400(
+  inp: [G; IN_400],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_492], ExecError> {
+) -> Result<[G; OUT_400], 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() {
+    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() {
       7u64 => {
-        match __v_3.as_canonical_u64() {
+        match __v_2.as_canonical_u64() {
           0u64 => {
+            let __v_5: G = G::from_u64(1);
             let __v_6: G = G::from_u64(1);
             let __v_7: G = G::from_u64(1);
-            let __v_8: G = G::from_u64(1);
-            let __v_9: G = { let __values: [G; 10] = [__v_7, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8]; 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_338] = { let __args: [G; IN_338] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } else { aiur_fn_338(__args, record, io_buffer, __cu)? } };
-            let __v_10: G = __r_arr[0];
-            let __ret: [G; OUT_492] = [__v_6, __v_10, __v_4];
-            record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; 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_227] = { let __args: [G; IN_227] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } else { aiur_fn_227(__args, record, io_buffer, __cu)? } };
+            let __v_9: G = __r_arr[0];
+            let __ret: [G; OUT_400] = [__v_5, __v_9, __v_3];
+            record.function_queries[400].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __v_6: G = G::from_u64(0);
+            let __v_5: G = G::from_u64(0);
+            let __v_6: G = G::from_u64(1);
             let __v_7: G = G::from_u64(1);
-            let __v_8: G = G::from_u64(1);
-            let __v_9: G = { let __values: [G; 10] = [__v_7, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8]; 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_492] = [__v_6, __v_0, __v_9];
-            record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; 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_400] = [__v_5, __v_0, __v_8];
+            record.function_queries[400].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
       3u64 => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; 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: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].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];
-        match __v_6.as_canonical_u64() {
+        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_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() {
           2u64 => {
-            let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_1, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[139].get_mut(&__args[..]) { 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_9: G = __r_arr[0];
+            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_10: G = __r_arr[0];
-            let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[273].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_273] = unsafe { *(result.output.as_ptr() as *const [G; OUT_273]) }; __ret } else { aiur_fn_273(__args, record, io_buffer, __cu)? } };
-            let __v_11: G = __r_arr[0];
-            let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_12: G = __r_arr[0];
-            match __v_12.as_canonical_u64() {
+            match __v_10.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_492] = { let __args: [G; IN_492] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[492].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_492] = unsafe { *(result.output.as_ptr() as *const [G; OUT_492]) }; __ret } else { aiur_fn_492(__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 = G::from_u64(1);
-                let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[304].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_304] = unsafe { *(result.output.as_ptr() as *const [G; OUT_304]) }; __ret } else { aiur_fn_304(__args, record, io_buffer, __cu)? } };
-                let __v_17: G = __r_arr[0];
-                let __ret: [G; OUT_492] = [__v_16, __v_14, __v_17];
-                record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              0u64 => {
-                let __v_13: G = G::from_u64(0);
+                let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__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 = G::from_u64(1);
-                let __v_15: G = G::from_u64(1);
-                let __v_16: G = { let __values: [G; 10] = [__v_14, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15]; 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_492] = [__v_13, __v_0, __v_16];
-                record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { 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_15: G = __r_arr[0];
+                let __ret: [G; OUT_400] = [__v_14, __v_12, __v_15];
+                record.function_queries[400].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64()));
+                let __v_11: G = G::from_u64(0);
+                let __v_12: G = G::from_u64(1);
+                let __v_13: G = G::from_u64(1);
+                let __v_14: G = { let __values: [G; 10] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __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_400] = [__v_11, __v_0, __v_14];
+                record.function_queries[400].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
               },
             }
           },
           3u64 => {
-            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; 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: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].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];
-            match __v_10.as_canonical_u64() {
+            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; 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: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].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];
+            match __v_9.as_canonical_u64() {
               2u64 => {
-                let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[141].get_mut(&__args[..]) { 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_13: G = __r_arr[0];
+                let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_10, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_14: G = __r_arr[0];
-                let __r_arr: [G; OUT_275] = { let __args: [G; IN_275] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[275].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_275] = unsafe { *(result.output.as_ptr() as *const [G; OUT_275]) }; __ret } else { aiur_fn_275(__args, record, io_buffer, __cu)? } };
-                let __v_15: G = __r_arr[0];
-                let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_16: G = __r_arr[0];
-                match __v_16.as_canonical_u64() {
+                match __v_14.as_canonical_u64() {
                   1u64 => {
-                    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_17: G = __loaded[0];
-                    let __v_18: G = __loaded[1];
-                    let __v_19: G = __loaded[2];
-                    let __v_20: G = __loaded[3];
-                    match __v_17.as_canonical_u64() {
+                    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; 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: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+                    let __v_15: G = __loaded[0];
+                    let __v_16: G = __loaded[1];
+                    let __v_17: G = __loaded[2];
+                    let __v_18: G = __loaded[3];
+                    match __v_15.as_canonical_u64() {
                       7u64 => {
-                        match __v_18.as_canonical_u64() {
+                        match __v_16.as_canonical_u64() {
                           0u64 => {
-                            let __r_arr: [G; OUT_492] = { let __args: [G; IN_492] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[492].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_492] = unsafe { *(result.output.as_ptr() as *const [G; OUT_492]) }; __ret } else { aiur_fn_492(__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];
-                            match __v_21.as_canonical_u64() {
+                            let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__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];
+                            match __v_19.as_canonical_u64() {
                               1u64 => {
-                                let __v_24: G = G::from_u64(1);
-                                let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_23, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } else { aiur_fn_306(__args, record, io_buffer, __cu)? } };
-                                let __v_25: G = __r_arr[0];
-                                let __ret: [G; OUT_492] = [__v_24, __v_22, __v_25];
-                                record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                                return Ok(__ret);
-                              },
-                              0u64 => {
-                                let __v_24: G = G::from_u64(1);
-                                let __ret: [G; OUT_492] = [__v_24, __v_8, __v_19];
-                                record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __v_22: G = G::from_u64(1);
+                                let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_21, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[109].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_109] = unsafe { *(result.output.as_ptr() as *const [G; OUT_109]) }; __ret } else { aiur_fn_109(__args, record, io_buffer, __cu)? } };
+                                let __v_23: G = __r_arr[0];
+                                let __ret: [G; OUT_400] = [__v_22, __v_20, __v_23];
+                                record.function_queries[400].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
-                                return Err(ExecError::MatchNoCase(__v_21.as_canonical_u64()));
+                                let __v_22: G = G::from_u64(1);
+                                let __ret: [G; OUT_400] = [__v_22, __v_7, __v_17];
+                                record.function_queries[400].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                return Ok(__ret);
                               },
                             }
                           },
                           _ => {
-                            let __v_21: G = G::from_u64(0);
-                            let __v_22: G = G::from_u64(1);
-                            let __v_23: G = G::from_u64(1);
-                            let __v_24: G = { let __values: [G; 10] = [__v_22, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; 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_492] = [__v_21, __v_0, __v_24];
-                            record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __v_19: G = G::from_u64(0);
+                            let __v_20: G = G::from_u64(1);
+                            let __v_21: G = G::from_u64(1);
+                            let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; 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_400] = [__v_19, __v_0, __v_22];
+                            record.function_queries[400].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                         }
                       },
                       _ => {
-                        let __v_21: G = G::from_u64(0);
-                        let __v_22: G = G::from_u64(1);
-                        let __v_23: G = G::from_u64(1);
-                        let __v_24: G = { let __values: [G; 10] = [__v_22, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; 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_492] = [__v_21, __v_0, __v_24];
-                        record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __v_19: G = G::from_u64(0);
+                        let __v_20: G = G::from_u64(1);
+                        let __v_21: G = G::from_u64(1);
+                        let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; 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_400] = [__v_19, __v_0, __v_22];
+                        record.function_queries[400].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                     }
                   },
-                  0u64 => {
-                    let __v_17: G = G::from_u64(0);
-                    let __v_18: G = G::from_u64(1);
-                    let __v_19: G = G::from_u64(1);
-                    let __v_20: G = { let __values: [G; 10] = [__v_18, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19]; 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_492] = [__v_17, __v_0, __v_20];
-                    record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
                   _ => {
-                    return Err(ExecError::MatchNoCase(__v_16.as_canonical_u64()));
+                    let __v_15: G = G::from_u64(0);
+                    let __v_16: G = G::from_u64(1);
+                    let __v_17: G = G::from_u64(1);
+                    let __v_18: G = { let __values: [G; 10] = [__v_16, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17]; 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_400] = [__v_15, __v_0, __v_18];
+                    record.function_queries[400].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
                   },
                 }
               },
               _ => {
-                let __v_14: G = G::from_u64(0);
+                let __v_13: G = G::from_u64(0);
+                let __v_14: G = G::from_u64(1);
                 let __v_15: G = G::from_u64(1);
-                let __v_16: G = G::from_u64(1);
-                let __v_17: G = { let __values: [G; 10] = [__v_15, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16]; 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_492] = [__v_14, __v_0, __v_17];
-                record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __v_16: G = { let __values: [G; 10] = [__v_14, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15]; 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_400] = [__v_13, __v_0, __v_16];
+                record.function_queries[400].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
           _ => {
-            let __v_10: G = G::from_u64(0);
+            let __v_9: G = G::from_u64(0);
+            let __v_10: G = G::from_u64(1);
             let __v_11: G = G::from_u64(1);
-            let __v_12: G = G::from_u64(1);
-            let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; 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_492] = [__v_10, __v_0, __v_13];
-            record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __v_12: G = { let __values: [G; 10] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; 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_400] = [__v_9, __v_0, __v_12];
+            record.function_queries[400].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
       _ => {
-        let __v_6: G = G::from_u64(0);
+        let __v_5: G = G::from_u64(0);
+        let __v_6: G = G::from_u64(1);
         let __v_7: G = G::from_u64(1);
-        let __v_8: G = G::from_u64(1);
-        let __v_9: G = { let __values: [G; 10] = [__v_7, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8]; 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_492] = [__v_6, __v_0, __v_9];
-        record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; 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_400] = [__v_5, __v_0, __v_8];
+        record.function_queries[400].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_493: usize = 5;
-const IN_493: usize = 5;
-const OUT_493: usize = 2;
-fn aiur_fn_493(
-  inp: [G; IN_493],
+const INPUT_SIZE_401: usize = 3;
+const IN_401: usize = 3;
+const OUT_401: usize = 2;
+fn aiur_fn_401(
+  inp: [G; IN_401],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_493], ExecError> {
+) -> Result<[G; OUT_401], 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_491] = { let __args: [G; IN_491] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[491].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_491] = unsafe { *(result.output.as_ptr() as *const [G; OUT_491]) }; __ret } else { aiur_fn_491(__args, record, io_buffer, __cu)? } };
-    let __v_5: G = __r_arr[0];
-    let __r_arr: [G; OUT_491] = { let __args: [G; IN_491] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[491].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_491] = unsafe { *(result.output.as_ptr() as *const [G; OUT_491]) }; __ret } else { aiur_fn_491(__args, record, io_buffer, __cu)? } };
-    let __v_6: G = __r_arr[0];
-    let __v_7: G = (__v_5 * __v_6);
-    match __v_7.as_canonical_u64() {
+    let __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[399].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_399] = unsafe { *(result.output.as_ptr() as *const [G; OUT_399]) }; __ret } else { aiur_fn_399(__args, record, io_buffer, __cu)? } };
+    let __v_3: G = __r_arr[0];
+    let __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[399].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_399] = unsafe { *(result.output.as_ptr() as *const [G; OUT_399]) }; __ret } else { aiur_fn_399(__args, record, io_buffer, __cu)? } };
+    let __v_4: G = __r_arr[0];
+    let __v_5: G = (__v_3 * __v_4);
+    match __v_5.as_canonical_u64() {
       1u64 => {
-        let __v_8: G = G::from_u64(1);
-        let __v_9: G = G::from_u64(1);
-        let __ret: [G; OUT_493] = [__v_8, __v_9];
-        record.function_queries[493].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __v_6: G = G::from_u64(1);
+        let __v_7: G = G::from_u64(1);
+        let __ret: [G; OUT_401] = [__v_6, __v_7];
+        record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __r_arr: [G; OUT_492] = { let __args: [G; IN_492] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[492].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_492] = unsafe { *(result.output.as_ptr() as *const [G; OUT_492]) }; __ret } else { aiur_fn_492(__args, record, io_buffer, __cu)? } };
-        let __v_8: G = __r_arr[0];
-        let __v_9: G = __r_arr[1];
-        let __v_10: G = __r_arr[2];
-        let __r_arr: [G; OUT_492] = { let __args: [G; IN_492] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[492].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_492] = unsafe { *(result.output.as_ptr() as *const [G; OUT_492]) }; __ret } else { aiur_fn_492(__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 = (__v_8 * __v_11);
-        match __v_14.as_canonical_u64() {
+      _ => {
+        let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__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 __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__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 = (__v_6 * __v_9);
+        match __v_12.as_canonical_u64() {
           0u64 => {
-            let __v_15: G = G::from_u64(0);
-            let __v_16: G = G::from_u64(0);
-            let __ret: [G; OUT_493] = [__v_15, __v_16];
-            record.function_queries[493].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __v_13: G = G::from_u64(0);
+            let __v_14: G = G::from_u64(0);
+            let __ret: [G; OUT_401] = [__v_13, __v_14];
+            record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_10, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_230] = unsafe { *(result.output.as_ptr() as *const [G; OUT_230]) }; __ret } else { aiur_fn_230(__args, record, io_buffer, __cu)? } };
-            let __v_15: G = __r_arr[0];
-            match __v_15.as_canonical_u64() {
+            let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } };
+            let __v_13: G = __r_arr[0];
+            match __v_13.as_canonical_u64() {
               0u64 => {
-                let __v_16: G = G::from_u64(0);
-                let __v_17: G = G::from_u64(0);
-                let __ret: [G; OUT_493] = [__v_16, __v_17];
-                record.function_queries[493].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              1u64 => {
-                let __v_16: G = G::from_u64(1);
-                let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_9, __v_12, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } };
-                let __v_17: G = __r_arr[0];
-                let __ret: [G; OUT_493] = [__v_16, __v_17];
-                record.function_queries[493].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __v_14: G = G::from_u64(0);
+                let __v_15: G = G::from_u64(0);
+                let __ret: [G; OUT_401] = [__v_14, __v_15];
+                record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                return Err(ExecError::MatchNoCase(__v_15.as_canonical_u64()));
+                let __v_14: G = G::from_u64(1);
+                let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_7, __v_10, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } };
+                let __v_15: G = __r_arr[0];
+                let __ret: [G; OUT_401] = [__v_14, __v_15];
+                record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
               },
             }
           },
         }
       },
+    }
+  })
+}
+
+const INPUT_SIZE_402: usize = 3;
+const IN_402: usize = 3;
+const OUT_402: usize = 1;
+fn aiur_fn_402(
+  inp: [G; IN_402],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_402], 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_403] = { let __args: [G; IN_403] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[403].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_403] = unsafe { *(result.output.as_ptr() as *const [G; OUT_403]) }; __ret } else { aiur_fn_403(__args, record, io_buffer, __cu)? } };
+    let __v_3: G = __r_arr[0];
+    match __v_3.as_canonical_u64() {
+      1u64 => {
+        let __v_4: G = G::from_u64(1);
+        let __ret: [G; OUT_402] = [__v_4];
+        record.function_queries[402].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64()));
+        let __r_arr: [G; OUT_403] = { let __args: [G; IN_403] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[403].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_403] = unsafe { *(result.output.as_ptr() as *const [G; OUT_403]) }; __ret } else { aiur_fn_403(__args, record, io_buffer, __cu)? } };
+        let __v_4: G = __r_arr[0];
+        let __ret: [G; OUT_402] = [__v_4];
+        record.function_queries[402].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_494: usize = 5;
-const IN_494: usize = 5;
-const OUT_494: usize = 1;
-fn aiur_fn_494(
-  inp: [G; IN_494],
+const INPUT_SIZE_403: usize = 3;
+const IN_403: usize = 3;
+const OUT_403: usize = 1;
+fn aiur_fn_403(
+  inp: [G; IN_403],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_494], ExecError> {
+) -> Result<[G; OUT_403], 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_189] = { let __args: [G; IN_189] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[189].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_189] = unsafe { *(result.output.as_ptr() as *const [G; OUT_189]) }; __ret } else { aiur_fn_189(__args, record, io_buffer, __cu)? } };
-    let __v_5: G = __r_arr[0];
-    let __v_6: G = __r_arr[1];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; 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: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].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];
-    match __v_7.as_canonical_u64() {
-      2u64 => {
-        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_3, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-        let __v_11: G = __r_arr[0];
-        let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr };
-        let __v_12: G = __loaded[0];
-        let __v_13: G = __loaded[1];
-        let __v_14: G = __loaded[2];
-        let __v_15: G = __loaded[3];
-        let __v_16: G = __loaded[4];
-        let __v_17: G = __loaded[5];
-        let __v_18: G = __loaded[6];
-        let __v_19: G = __loaded[7];
-        let __v_20: G = __loaded[8];
-        let __v_21: G = __loaded[9];
-        let __v_22: G = __loaded[10];
-        match __v_12.as_canonical_u64() {
-          6u64 => {
-            let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { 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_23: G = __r_arr[0];
-            let __v_24: G = (__v_17 + __v_18);
-            let __v_25: G = (__v_23 - __v_24);
-            match __v_25.as_canonical_u64() {
-              0u64 => {
-                let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-                let __v_26: G = __r_arr[0];
-                let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_26.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr };
-                let __v_27: G = __loaded[0];
-                let __v_28: G = __loaded[1];
-                let __v_29: G = __loaded[2];
-                let __v_30: G = __loaded[3];
-                let __v_31: G = __loaded[4];
-                let __v_32: G = __loaded[5];
-                let __v_33: G = __loaded[6];
-                let __v_34: G = __loaded[7];
-                let __v_35: G = __loaded[8];
-                let __v_36: G = __loaded[9];
-                let __v_37: G = __loaded[10];
-                match __v_27.as_canonical_u64() {
-                  5u64 => {
-                    let __v_38: G = G::from_bool((__v_31 == G::ZERO));
-                    let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { 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_39: G = __r_arr[0];
-                    let __v_40: G = G::from_u64(1);
-                    let __v_41: G = (__v_39 - __v_40);
-                    let __v_42: G = G::from_bool((__v_41 == G::ZERO));
-                    let __v_43: G = (__v_38 * __v_42);
-                    match __v_43.as_canonical_u64() {
-                      0u64 => {
-                        let __v_44: G = G::from_u64(0);
-                        let __ret: [G; OUT_494] = [__v_44];
-                        record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                        return Ok(__ret);
-                      },
-                      1u64 => {
-                        let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_15, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } else { aiur_fn_529(__args, record, io_buffer, __cu)? } };
-                        let __v_44: G = __r_arr[0];
-                        match __v_44.as_canonical_u64() {
-                          1u64 => {
-                            let __v_45: G = G::from_u64(0);
-                            let __ret: [G; OUT_494] = [__v_45];
-                            record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                            return Ok(__ret);
-                          },
-                          0u64 => {
-                            let __v_45: G = G::from_u64(0);
-                            let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_15, __v_17, __v_18, __v_0, __v_6, __v_45, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } else { aiur_fn_495(__args, record, io_buffer, __cu)? } };
-                            let __v_46: G = __r_arr[0];
-                            let __ret: [G; OUT_494] = [__v_46];
-                            record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                            return Ok(__ret);
-                          },
-                          _ => {
-                            return Err(ExecError::MatchNoCase(__v_44.as_canonical_u64()));
-                          },
-                        }
-                      },
-                      _ => {
-                        return Err(ExecError::MatchNoCase(__v_43.as_canonical_u64()));
-                      },
-                    }
-                  },
-                  _ => {
-                    let __v_38: G = G::from_u64(0);
-                    let __ret: [G; OUT_494] = [__v_38];
-                    record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
-                }
-              },
-              _ => {
-                let __v_26: G = G::from_u64(0);
-                let __ret: [G; OUT_494] = [__v_26];
-                record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-            }
+    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_3: G = __loaded[0];
+    let __v_4: G = __loaded[1];
+    let __v_5: G = __loaded[2];
+    let __v_6: G = __loaded[3];
+    match __v_3.as_canonical_u64() {
+      7u64 => {
+        match __v_4.as_canonical_u64() {
+          1u64 => {
+            let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[211].get_mut(&__args[..]) { 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_7: G = __r_arr[0];
+            let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_7, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } };
+            let __v_9: G = __r_arr[0];
+            let __ret: [G; OUT_403] = [__v_9];
+            record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
           },
           _ => {
-            let __v_23: G = G::from_u64(0);
-            let __ret: [G; OUT_494] = [__v_23];
-            record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __v_7: G = G::from_u64(0);
+            let __ret: [G; OUT_403] = [__v_7];
+            record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
       _ => {
-        let __v_11: G = G::from_u64(0);
-        let __ret: [G; OUT_494] = [__v_11];
-        record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __v_7: G = G::from_u64(0);
+        let __ret: [G; OUT_403] = [__v_7];
+        record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_495: usize = 9;
-const IN_495: usize = 9;
-const OUT_495: usize = 1;
-fn aiur_fn_495(
-  inp: [G; IN_495],
+const INPUT_SIZE_404: usize = 3;
+const IN_404: usize = 3;
+const OUT_404: usize = 1;
+fn aiur_fn_404(
+  inp: [G; IN_404],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_495], ExecError> {
+) -> Result<[G; OUT_404], 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 = (__v_2 - __v_5);
-    match __v_9.as_canonical_u64() {
-      0u64 => {
-        let __v_10: G = G::from_u64(1);
-        let __ret: [G; OUT_495] = [__v_10];
-        record.function_queries[495].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __r_arr: [G; OUT_402] = { let __args: [G; IN_402] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[402].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_402] = unsafe { *(result.output.as_ptr() as *const [G; OUT_402]) }; __ret } else { aiur_fn_402(__args, record, io_buffer, __cu)? } };
+    let __v_3: G = __r_arr[0];
+    match __v_3.as_canonical_u64() {
+      1u64 => {
+        let __v_4: G = G::from_u64(1);
+        let __ret: [G; OUT_404] = [__v_4];
+        record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __v_10: G = G::from_u64(8);
-        let __v_11: G = { let __values: [G; 4] = [__v_10, __v_0, __v_5, __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 __v_12: G = (__v_1 + __v_5);
-        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_4, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-        let __v_13: G = __r_arr[0];
-        let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_11, __v_13, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } };
-        let __v_14: G = __r_arr[0];
-        match __v_14.as_canonical_u64() {
-          0u64 => {
-            let __v_15: G = G::from_u64(0);
-            let __ret: [G; OUT_495] = [__v_15];
-            record.function_queries[495].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          1u64 => {
-            let __v_15: G = G::from_u64(1);
-            let __v_16: G = (__v_5 + __v_15);
-            let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_16, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } else { aiur_fn_495(__args, record, io_buffer, __cu)? } };
-            let __v_17: G = __r_arr[0];
-            let __ret: [G; OUT_495] = [__v_17];
-            record.function_queries[495].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64()));
-          },
-        }
+        let __r_arr: [G; OUT_405] = { let __args: [G; IN_405] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[405].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_405] = unsafe { *(result.output.as_ptr() as *const [G; OUT_405]) }; __ret } else { aiur_fn_405(__args, record, io_buffer, __cu)? } };
+        let __v_4: G = __r_arr[0];
+        let __ret: [G; OUT_404] = [__v_4];
+        record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_496: usize = 5;
-const IN_496: usize = 5;
-const OUT_496: usize = 1;
-fn aiur_fn_496(
-  inp: [G; IN_496],
+const INPUT_SIZE_405: usize = 3;
+const IN_405: usize = 3;
+const OUT_405: usize = 1;
+fn aiur_fn_405(
+  inp: [G; IN_405],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_496], ExecError> {
+) -> Result<[G; OUT_405], 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 __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_5: G = __loaded[0];
-    let __v_6: G = __loaded[1];
-    let __v_7: G = __loaded[2];
-    let __v_8: G = __loaded[3];
+    let __r_arr: [G; OUT_379] = { let __args: [G; IN_379] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[379].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_379] = unsafe { *(result.output.as_ptr() as *const [G; OUT_379]) }; __ret } else { aiur_fn_379(__args, record, io_buffer, __cu)? } };
+    let __v_3: G = __r_arr[0];
+    let __r_arr: [G; OUT_379] = { let __args: [G; IN_379] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[379].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_379] = unsafe { *(result.output.as_ptr() as *const [G; OUT_379]) }; __ret } else { aiur_fn_379(__args, record, io_buffer, __cu)? } };
+    let __v_4: G = __r_arr[0];
+    let __v_5: G = (__v_3 - __v_4);
     match __v_5.as_canonical_u64() {
-      1u64 => {
-        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_9: G = __loaded[0];
-        let __v_10: G = __loaded[1];
-        let __v_11: G = __loaded[2];
-        let __v_12: G = __loaded[3];
-        match __v_9.as_canonical_u64() {
-          1u64 => {
-            let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_6, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[216].get_mut(&__args[..]) { 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_13: G = __r_arr[0];
-            let __ret: [G; OUT_496] = [__v_13];
-            record.function_queries[496].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          4u64 => {
-            let __r_arr: [G; OUT_497] = { let __args: [G; IN_497] = [__v_10, __v_11, __v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[497].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_497] = unsafe { *(result.output.as_ptr() as *const [G; OUT_497]) }; __ret } else { aiur_fn_497(__args, record, io_buffer, __cu)? } };
-            let __v_13: G = __r_arr[0];
-            let __ret: [G; OUT_496] = [__v_13];
-            record.function_queries[496].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            let __v_13: G = G::from_u64(0);
-            let __ret: [G; OUT_496] = [__v_13];
-            record.function_queries[496].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_9: G = __loaded[0];
-        let __v_10: G = __loaded[1];
-        let __v_11: G = __loaded[2];
-        let __v_12: G = __loaded[3];
-        match __v_9.as_canonical_u64() {
-          0u64 => {
-            let __v_13: G = (__v_6 - __v_10);
-            match __v_13.as_canonical_u64() {
-              0u64 => {
-                let __v_14: G = G::from_u64(1);
-                let __ret: [G; OUT_496] = [__v_14];
-                record.function_queries[496].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              _ => {
-                let __v_14: G = G::from_u64(0);
-                let __ret: [G; OUT_496] = [__v_14];
-                record.function_queries[496].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-            }
-          },
-          4u64 => {
-            let __r_arr: [G; OUT_497] = { let __args: [G; IN_497] = [__v_10, __v_11, __v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[497].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_497] = unsafe { *(result.output.as_ptr() as *const [G; OUT_497]) }; __ret } else { aiur_fn_497(__args, record, io_buffer, __cu)? } };
-            let __v_13: G = __r_arr[0];
-            let __ret: [G; OUT_496] = [__v_13];
-            record.function_queries[496].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            let __v_13: G = G::from_u64(0);
-            let __ret: [G; OUT_496] = [__v_13];
-            record.function_queries[496].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-        }
+        let __v_6: G = G::from_u64(1);
+        let __ret: [G; OUT_405] = [__v_6];
+        record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
-      2u64 => {
-        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_9: G = __loaded[0];
-        let __v_10: G = __loaded[1];
-        let __v_11: G = __loaded[2];
-        let __v_12: G = __loaded[3];
-        match __v_9.as_canonical_u64() {
-          2u64 => {
-            let __v_13: G = (__v_6 - __v_10);
-            match __v_13.as_canonical_u64() {
-              0u64 => {
-                let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_7, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[498].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_498] = unsafe { *(result.output.as_ptr() as *const [G; OUT_498]) }; __ret } else { aiur_fn_498(__args, record, io_buffer, __cu)? } };
-                let __v_14: G = __r_arr[0];
-                let __ret: [G; OUT_496] = [__v_14];
-                record.function_queries[496].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              _ => {
-                let __v_14: G = G::from_u64(0);
-                let __ret: [G; OUT_496] = [__v_14];
-                record.function_queries[496].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-            }
-          },
-          4u64 => {
-            let __r_arr: [G; OUT_497] = { let __args: [G; IN_497] = [__v_10, __v_11, __v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[497].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_497] = unsafe { *(result.output.as_ptr() as *const [G; OUT_497]) }; __ret } else { aiur_fn_497(__args, record, io_buffer, __cu)? } };
-            let __v_13: G = __r_arr[0];
-            let __ret: [G; OUT_496] = [__v_13];
-            record.function_queries[496].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+      _ => {
+        let __r_arr: [G; OUT_406] = { let __args: [G; IN_406] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[406].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_406] = unsafe { *(result.output.as_ptr() as *const [G; OUT_406]) }; __ret } else { aiur_fn_406(__args, record, io_buffer, __cu)? } };
+        let __v_6: G = __r_arr[0];
+        match __v_6.as_canonical_u64() {
+          1u64 => {
+            let __v_7: G = G::from_u64(1);
+            let __ret: [G; OUT_405] = [__v_7];
+            record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __v_13: G = G::from_u64(0);
-            let __ret: [G; OUT_496] = [__v_13];
-            record.function_queries[496].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-        }
-      },
-      3u64 => {
-        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_9: G = __loaded[0];
-        let __v_10: G = __loaded[1];
-        let __v_11: G = __loaded[2];
-        let __v_12: G = __loaded[3];
-        match __v_9.as_canonical_u64() {
-          3u64 => {
-            let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_6, __v_10, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } };
-            let __v_13: G = __r_arr[0];
-            match __v_13.as_canonical_u64() {
+            let __r_arr: [G; OUT_397] = { let __args: [G; IN_397] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[397].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_397] = unsafe { *(result.output.as_ptr() as *const [G; OUT_397]) }; __ret } else { aiur_fn_397(__args, record, io_buffer, __cu)? } };
+            let __v_7: G = __r_arr[0];
+            match __v_7.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_7, __v_11, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } };
-                let __v_14: G = __r_arr[0];
-                let __ret: [G; OUT_496] = [__v_14];
-                record.function_queries[496].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              0u64 => {
-                let __v_14: G = G::from_u64(0);
-                let __ret: [G; OUT_496] = [__v_14];
-                record.function_queries[496].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __v_8: G = G::from_u64(1);
+                let __ret: [G; OUT_405] = [__v_8];
+                record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64()));
-              },
-            }
-          },
-          4u64 => {
-            let __r_arr: [G; OUT_497] = { let __args: [G; IN_497] = [__v_10, __v_11, __v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[497].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_497] = unsafe { *(result.output.as_ptr() as *const [G; OUT_497]) }; __ret } else { aiur_fn_497(__args, record, io_buffer, __cu)? } };
-            let __v_13: G = __r_arr[0];
-            let __ret: [G; OUT_496] = [__v_13];
-            record.function_queries[496].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            let __v_13: G = G::from_u64(0);
-            let __ret: [G; OUT_496] = [__v_13];
-            record.function_queries[496].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-        }
-      },
-      4u64 => {
-        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_9: G = __loaded[0];
-        let __v_10: G = __loaded[1];
-        let __v_11: G = __loaded[2];
-        let __v_12: G = __loaded[3];
-        match __v_9.as_canonical_u64() {
-          4u64 => {
-            let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_6, __v_10, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } };
-            let __v_13: G = __r_arr[0];
-            match __v_13.as_canonical_u64() {
-              1u64 => {
-                let __v_14: G = G::from_u64(0);
-                let __v_15: G = { let __values: [G; 3] = [__v_14, __v_6, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_481] = { let __args: [G; IN_481] = [__v_7, __v_11, __v_15, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } };
-                let __v_16: G = __r_arr[0];
-                let __ret: [G; OUT_496] = [__v_16];
-                record.function_queries[496].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              0u64 => {
-                let __v_14: G = G::from_u64(0);
-                let __ret: [G; OUT_496] = [__v_14];
-                record.function_queries[496].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[407].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_407] = unsafe { *(result.output.as_ptr() as *const [G; OUT_407]) }; __ret } else { aiur_fn_407(__args, record, io_buffer, __cu)? } };
+                let __v_8: G = __r_arr[0];
+                let __ret: [G; OUT_405] = [__v_8];
+                record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
-              _ => {
-                return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64()));
-              },
             }
           },
-          _ => {
-            let __r_arr: [G; OUT_497] = { let __args: [G; IN_497] = [__v_6, __v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[497].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_497] = unsafe { *(result.output.as_ptr() as *const [G; OUT_497]) }; __ret } else { aiur_fn_497(__args, record, io_buffer, __cu)? } };
-            let __v_13: G = __r_arr[0];
-            let __ret: [G; OUT_496] = [__v_13];
-            record.function_queries[496].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
         }
       },
-      5u64 => {
+    }
+  })
+}
+
+const INPUT_SIZE_406: usize = 3;
+const IN_406: usize = 3;
+const OUT_406: usize = 1;
+fn aiur_fn_406(
+  inp: [G; IN_406],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_406], 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; 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_3: G = __loaded[0];
+    let __v_4: G = __loaded[1];
+    let __v_5: G = __loaded[2];
+    let __v_6: G = __loaded[3];
+    match __v_3.as_canonical_u64() {
+      1u64 => {
         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_9: G = __loaded[0];
-        let __v_10: G = __loaded[1];
-        let __v_11: G = __loaded[2];
-        let __v_12: G = __loaded[3];
-        match __v_9.as_canonical_u64() {
-          5u64 => {
-            let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_6, __v_10, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } };
-            let __v_13: G = __r_arr[0];
-            match __v_13.as_canonical_u64() {
-              1u64 => {
-                let __v_14: G = G::from_u64(0);
-                let __v_15: G = { let __values: [G; 3] = [__v_14, __v_6, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_481] = { let __args: [G; IN_481] = [__v_7, __v_11, __v_15, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } };
-                let __v_16: G = __r_arr[0];
-                let __ret: [G; OUT_496] = [__v_16];
-                record.function_queries[496].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              0u64 => {
-                let __v_14: G = G::from_u64(0);
-                let __ret: [G; OUT_496] = [__v_14];
-                record.function_queries[496].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              _ => {
-                return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64()));
-              },
-            }
-          },
-          4u64 => {
-            let __r_arr: [G; OUT_497] = { let __args: [G; IN_497] = [__v_10, __v_11, __v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[497].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_497] = unsafe { *(result.output.as_ptr() as *const [G; OUT_497]) }; __ret } else { aiur_fn_497(__args, record, io_buffer, __cu)? } };
-            let __v_13: G = __r_arr[0];
-            let __ret: [G; OUT_496] = [__v_13];
-            record.function_queries[496].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __v_7: G = __loaded[0];
+        let __v_8: G = __loaded[1];
+        let __v_9: G = __loaded[2];
+        let __v_10: G = __loaded[3];
+        match __v_7.as_canonical_u64() {
+          1u64 => {
+            let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } else { aiur_fn_295(__args, record, io_buffer, __cu)? } };
+            let __v_11: G = __r_arr[0];
+            let __ret: [G; OUT_406] = [__v_11];
+            record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __v_13: G = G::from_u64(0);
-            let __ret: [G; OUT_496] = [__v_13];
-            record.function_queries[496].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __v_11: G = G::from_u64(0);
+            let __ret: [G; OUT_406] = [__v_11];
+            record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
-      6u64 => {
+      4u64 => {
         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_9: G = __loaded[0];
-        let __v_10: G = __loaded[1];
-        let __v_11: G = __loaded[2];
-        let __v_12: G = __loaded[3];
-        match __v_9.as_canonical_u64() {
-          6u64 => {
-            let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_6, __v_10, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } };
-            let __v_13: G = __r_arr[0];
-            match __v_13.as_canonical_u64() {
+        let __v_7: G = __loaded[0];
+        let __v_8: G = __loaded[1];
+        let __v_9: G = __loaded[2];
+        let __v_10: G = __loaded[3];
+        match __v_7.as_canonical_u64() {
+          4u64 => {
+            let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } };
+            let __v_11: G = __r_arr[0];
+            match __v_11.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_7, __v_11, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } };
+                let __v_12: G = G::from_u64(0);
+                let __v_13: G = { let __values: [G; 3] = [__v_12, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_394] = { let __args: [G; IN_394] = [__v_5, __v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } };
                 let __v_14: G = __r_arr[0];
-                match __v_14.as_canonical_u64() {
-                  1u64 => {
-                    let __v_15: G = G::from_u64(0);
-                    let __v_16: G = { let __values: [G; 3] = [__v_15, __v_6, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_481] = { let __args: [G; IN_481] = [__v_8, __v_12, __v_16, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } };
-                    let __v_17: G = __r_arr[0];
-                    let __ret: [G; OUT_496] = [__v_17];
-                    record.function_queries[496].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
-                  0u64 => {
-                    let __v_15: G = G::from_u64(0);
-                    let __ret: [G; OUT_496] = [__v_15];
-                    record.function_queries[496].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
-                  _ => {
-                    return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64()));
-                  },
-                }
-              },
-              0u64 => {
-                let __v_14: G = G::from_u64(0);
-                let __ret: [G; OUT_496] = [__v_14];
-                record.function_queries[496].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_406] = [__v_14];
+                record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
-              },
-              _ => {
-                return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64()));
-              },
-            }
-          },
-          4u64 => {
-            let __r_arr: [G; OUT_497] = { let __args: [G; IN_497] = [__v_10, __v_11, __v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[497].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_497] = unsafe { *(result.output.as_ptr() as *const [G; OUT_497]) }; __ret } else { aiur_fn_497(__args, record, io_buffer, __cu)? } };
-            let __v_13: G = __r_arr[0];
-            let __ret: [G; OUT_496] = [__v_13];
-            record.function_queries[496].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            let __v_13: G = G::from_u64(0);
-            let __ret: [G; OUT_496] = [__v_13];
-            record.function_queries[496].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-        }
-      },
-      7u64 => {
-        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_9: G = __loaded[0];
-        let __v_10: G = __loaded[1];
-        let __v_11: G = __loaded[2];
-        let __v_12: G = __loaded[3];
-        match __v_9.as_canonical_u64() {
-          7u64 => {
-            let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_6, __v_7, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[232].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_232] = unsafe { *(result.output.as_ptr() as *const [G; OUT_232]) }; __ret } else { aiur_fn_232(__args, record, io_buffer, __cu)? } };
-            let __v_13: G = __r_arr[0];
-            let __ret: [G; OUT_496] = [__v_13];
-            record.function_queries[496].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          4u64 => {
-            let __r_arr: [G; OUT_497] = { let __args: [G; IN_497] = [__v_10, __v_11, __v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[497].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_497] = unsafe { *(result.output.as_ptr() as *const [G; OUT_497]) }; __ret } else { aiur_fn_497(__args, record, io_buffer, __cu)? } };
-            let __v_13: G = __r_arr[0];
-            let __ret: [G; OUT_496] = [__v_13];
-            record.function_queries[496].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
+              },
+              _ => {
+                let __v_12: G = G::from_u64(0);
+                let __ret: [G; OUT_406] = [__v_12];
+                record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+            }
           },
           _ => {
-            let __v_13: G = G::from_u64(0);
-            let __ret: [G; OUT_496] = [__v_13];
-            record.function_queries[496].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __v_11: G = G::from_u64(0);
+            let __ret: [G; OUT_406] = [__v_11];
+            record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
-      8u64 => {
+      5u64 => {
         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_9: G = __loaded[0];
-        let __v_10: G = __loaded[1];
-        let __v_11: G = __loaded[2];
-        let __v_12: G = __loaded[3];
-        match __v_9.as_canonical_u64() {
-          8u64 => {
-            let __v_13: G = (__v_6 - __v_10);
-            let __v_14: G = G::from_bool((__v_13 == G::ZERO));
-            let __v_15: G = (__v_7 - __v_11);
-            let __v_16: G = G::from_bool((__v_15 == G::ZERO));
-            let __v_17: G = (__v_14 * __v_16);
-            match __v_17.as_canonical_u64() {
+        let __v_7: G = __loaded[0];
+        let __v_8: G = __loaded[1];
+        let __v_9: G = __loaded[2];
+        let __v_10: G = __loaded[3];
+        match __v_7.as_canonical_u64() {
+          5u64 => {
+            let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } };
+            let __v_11: G = __r_arr[0];
+            match __v_11.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_8, __v_12, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } };
-                let __v_18: G = __r_arr[0];
-                let __ret: [G; OUT_496] = [__v_18];
-                record.function_queries[496].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              0u64 => {
-                let __v_18: G = G::from_u64(0);
-                let __ret: [G; OUT_496] = [__v_18];
-                record.function_queries[496].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __v_12: G = G::from_u64(0);
+                let __v_13: G = { let __values: [G; 3] = [__v_12, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_394] = { let __args: [G; IN_394] = [__v_5, __v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } };
+                let __v_14: G = __r_arr[0];
+                let __ret: [G; OUT_406] = [__v_14];
+                record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                return Err(ExecError::MatchNoCase(__v_17.as_canonical_u64()));
+                let __v_12: G = G::from_u64(0);
+                let __ret: [G; OUT_406] = [__v_12];
+                record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
               },
             }
           },
-          4u64 => {
-            let __r_arr: [G; OUT_497] = { let __args: [G; IN_497] = [__v_10, __v_11, __v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[497].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_497] = unsafe { *(result.output.as_ptr() as *const [G; OUT_497]) }; __ret } else { aiur_fn_497(__args, record, io_buffer, __cu)? } };
-            let __v_13: G = __r_arr[0];
-            let __ret: [G; OUT_496] = [__v_13];
-            record.function_queries[496].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
           _ => {
-            let __v_13: G = G::from_u64(0);
-            let __ret: [G; OUT_496] = [__v_13];
-            record.function_queries[496].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __v_11: G = G::from_u64(0);
+            let __ret: [G; OUT_406] = [__v_11];
+            record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
+        let __v_7: G = G::from_u64(0);
+        let __ret: [G; OUT_406] = [__v_7];
+        record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_497: usize = 6;
-const IN_497: usize = 6;
-const OUT_497: usize = 1;
-fn aiur_fn_497(
-  inp: [G; IN_497],
+const INPUT_SIZE_407: usize = 3;
+const IN_407: usize = 3;
+const OUT_407: usize = 1;
+fn aiur_fn_407(
+  inp: [G; IN_407],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_497], ExecError> {
+) -> Result<[G; OUT_407], 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(0);
-    let __r_arr: [G; OUT_413] = { let __args: [G; IN_413] = [__v_2, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[413].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_413] = unsafe { *(result.output.as_ptr() as *const [G; OUT_413]) }; __ret } else { aiur_fn_413(__args, record, io_buffer, __cu)? } };
-    let __v_8: G = __r_arr[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 = { let __values: [G; 4] = [__v_9, __v_10, __v_11, __v_11]; 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_13: G = G::from_u64(3);
-    let __v_14: G = G::from_u64(0);
-    let __v_15: G = { let __values: [G; 4] = [__v_13, __v_8, __v_12, __v_14]; 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_16: G = G::from_u64(0);
-    let __v_17: G = { let __values: [G; 3] = [__v_16, __v_0, __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_481] = { let __args: [G; IN_481] = [__v_1, __v_15, __v_17, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } };
-    let __v_18: G = __r_arr[0];
-    let __ret: [G; OUT_497] = [__v_18];
-    record.function_queries[497].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_498: usize = 2;
-const IN_498: usize = 2;
-const OUT_498: usize = 1;
-fn aiur_fn_498(
-  inp: [G; IN_498],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_498], 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 __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_5: G = __loaded[0];
-        let __v_6: G = __loaded[1];
-        let __v_7: G = __loaded[2];
-        match __v_5.as_canonical_u64() {
-          1u64 => {
-            let __v_8: G = G::from_u64(1);
-            let __ret: [G; OUT_498] = [__v_8];
-            record.function_queries[498].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_498] = [__v_8];
-            record.function_queries[498].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-        }
-      },
+    let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = unsafe { *(result.output.as_ptr() as *const [G; OUT_377]) }; __ret } else { aiur_fn_377(__args, record, io_buffer, __cu)? } };
+    let __v_3: G = __r_arr[0];
+    let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = unsafe { *(result.output.as_ptr() as *const [G; OUT_377]) }; __ret } else { aiur_fn_377(__args, record, io_buffer, __cu)? } };
+    let __v_4: G = __r_arr[0];
+    let __v_5: G = (__v_3 - __v_4);
+    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_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_5: G = __loaded[0];
-        let __v_6: G = __loaded[1];
-        let __v_7: G = __loaded[2];
-        match __v_5.as_canonical_u64() {
+        let __v_6: G = G::from_u64(1);
+        let __ret: [G; OUT_407] = [__v_6];
+        record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } else { aiur_fn_414(__args, record, io_buffer, __cu)? } };
+        let __v_6: G = __r_arr[0];
+        match __v_6.as_canonical_u64() {
           1u64 => {
-            let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_498] = [__v_8];
-            record.function_queries[498].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __v_7: G = G::from_u64(1);
+            let __ret: [G; OUT_407] = [__v_7];
+            record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
-          0u64 => {
-            let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[216].get_mut(&__args[..]) { 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_8: G = __r_arr[0];
-            match __v_8.as_canonical_u64() {
+          _ => {
+            let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[412].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_412] = unsafe { *(result.output.as_ptr() as *const [G; OUT_412]) }; __ret } else { aiur_fn_412(__args, record, io_buffer, __cu)? } };
+            let __v_7: G = __r_arr[0];
+            match __v_7.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[498].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_498] = unsafe { *(result.output.as_ptr() as *const [G; OUT_498]) }; __ret } else { aiur_fn_498(__args, record, io_buffer, __cu)? } };
-                let __v_9: G = __r_arr[0];
-                let __ret: [G; OUT_498] = [__v_9];
-                record.function_queries[498].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              0u64 => {
-                let __v_9: G = G::from_u64(0);
-                let __ret: [G; OUT_498] = [__v_9];
-                record.function_queries[498].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __v_8: G = G::from_u64(1);
+                let __ret: [G; OUT_407] = [__v_8];
+                record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64()));
+                let __r_arr: [G; OUT_408] = { let __args: [G; IN_408] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[408].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_408] = unsafe { *(result.output.as_ptr() as *const [G; OUT_408]) }; __ret } else { aiur_fn_408(__args, record, io_buffer, __cu)? } };
+                let __v_8: G = __r_arr[0];
+                match __v_8.as_canonical_u64() {
+                  1u64 => {
+                    let __v_9: G = G::from_u64(1);
+                    let __ret: [G; OUT_407] = [__v_9];
+                    record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
+                  },
+                  _ => {
+                    let __r_arr: [G; OUT_408] = { let __args: [G; IN_408] = [__v_4, __v_3, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[408].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_408] = unsafe { *(result.output.as_ptr() as *const [G; OUT_408]) }; __ret } else { aiur_fn_408(__args, record, io_buffer, __cu)? } };
+                    let __v_9: G = __r_arr[0];
+                    match __v_9.as_canonical_u64() {
+                      1u64 => {
+                        let __v_10: G = G::from_u64(1);
+                        let __ret: [G; OUT_407] = [__v_10];
+                        record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        return Ok(__ret);
+                      },
+                      _ => {
+                        let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } };
+                        let __v_10: G = __r_arr[0];
+                        let __v_11: G = __r_arr[1];
+                        match __v_10.as_canonical_u64() {
+                          1u64 => {
+                            let __ret: [G; OUT_407] = [__v_11];
+                            record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            return Ok(__ret);
+                          },
+                          _ => {
+                            let __v_12: G = G::from_u64(16);
+                            let __r_arr: [G; OUT_419] = { let __args: [G; IN_419] = [__v_3, __v_4, __v_12, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[419].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_419] = unsafe { *(result.output.as_ptr() as *const [G; OUT_419]) }; __ret } else { aiur_fn_419(__args, record, io_buffer, __cu)? } };
+                            let __v_13: G = __r_arr[0];
+                            match __v_13.as_canonical_u64() {
+                              1u64 => {
+                                let __v_14: G = G::from_u64(1);
+                                let __ret: [G; OUT_407] = [__v_14];
+                                record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                return Ok(__ret);
+                              },
+                              _ => {
+                                let __r_arr: [G; OUT_411] = { let __args: [G; IN_411] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[411].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_411] = unsafe { *(result.output.as_ptr() as *const [G; OUT_411]) }; __ret } else { aiur_fn_411(__args, record, io_buffer, __cu)? } };
+                                let __v_14: G = __r_arr[0];
+                                match __v_14.as_canonical_u64() {
+                                  1u64 => {
+                                    let __v_15: G = G::from_u64(1);
+                                    let __ret: [G; OUT_407] = [__v_15];
+                                    record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                    return Ok(__ret);
+                                  },
+                                  _ => {
+                                    let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } else { aiur_fn_417(__args, record, io_buffer, __cu)? } };
+                                    let __v_15: G = __r_arr[0];
+                                    let __ret: [G; OUT_407] = [__v_15];
+                                    record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                    return Ok(__ret);
+                                  },
+                                }
+                              },
+                            }
+                          },
+                        }
+                      },
+                    }
+                  },
+                }
               },
             }
           },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
-          },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
     }
   })
 }
 
-const INPUT_SIZE_499: usize = 5;
-const IN_499: usize = 5;
-const OUT_499: usize = 1;
-fn aiur_fn_499(
-  inp: [G; IN_499],
+const INPUT_SIZE_408: usize = 3;
+const IN_408: usize = 3;
+const OUT_408: usize = 1;
+fn aiur_fn_408(
+  inp: [G; IN_408],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_499], ExecError> {
+) -> Result<[G; OUT_408], 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_189] = { let __args: [G; IN_189] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[189].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_189] = unsafe { *(result.output.as_ptr() as *const [G; OUT_189]) }; __ret } else { aiur_fn_189(__args, record, io_buffer, __cu)? } };
-    let __v_5: G = __r_arr[0];
-    let __v_6: G = __r_arr[1];
-    let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[189].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_189] = unsafe { *(result.output.as_ptr() as *const [G; OUT_189]) }; __ret } else { aiur_fn_189(__args, record, io_buffer, __cu)? } };
-    let __v_7: G = __r_arr[0];
-    let __v_8: G = __r_arr[1];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; 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: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].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];
-    match __v_9.as_canonical_u64() {
+    let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[106].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_106] = unsafe { *(result.output.as_ptr() as *const [G; OUT_106]) }; __ret } else { aiur_fn_106(__args, record, io_buffer, __cu)? } };
+    let __v_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; 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: 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() {
       2u64 => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; 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: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
-        let __v_13: G = __loaded[0];
-        let __v_14: G = __loaded[1];
-        let __v_15: G = __loaded[2];
-        let __v_16: G = __loaded[3];
-        match __v_13.as_canonical_u64() {
-          2u64 => {
-            let __v_17: G = (__v_10 - __v_14);
-            match __v_17.as_canonical_u64() {
+        let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[258].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_258] = unsafe { *(result.output.as_ptr() as *const [G; OUT_258]) }; __ret } else { aiur_fn_258(__args, record, io_buffer, __cu)? } };
+        let __v_9: G = __r_arr[0];
+        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; 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: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].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];
+        match __v_10.as_canonical_u64() {
+          6u64 => {
+            let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } else { aiur_fn_711(__args, record, io_buffer, __cu)? } };
+            let __v_22: G = __r_arr[0];
+            let __v_23: G = (__v_16 + __v_17);
+            let __v_24: G = (__v_22 - __v_23);
+            match __v_24.as_canonical_u64() {
               0u64 => {
-                let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_11, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[498].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_498] = unsafe { *(result.output.as_ptr() as *const [G; OUT_498]) }; __ret } else { aiur_fn_498(__args, record, io_buffer, __cu)? } };
-                let __v_18: G = __r_arr[0];
-                match __v_18.as_canonical_u64() {
-                  0u64 => {
-                    let __v_19: G = G::from_u64(0);
-                    let __ret: [G; OUT_499] = [__v_19];
-                    record.function_queries[499].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
-                  1u64 => {
-                    let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { 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_19: G = __r_arr[0];
-                    let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { 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_20: G = __r_arr[0];
-                    let __v_21: G = (__v_19 - __v_20);
-                    match __v_21.as_canonical_u64() {
+                let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[260].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_260] = unsafe { *(result.output.as_ptr() as *const [G; OUT_260]) }; __ret } else { aiur_fn_260(__args, record, io_buffer, __cu)? } };
+                let __v_25: G = __r_arr[0];
+                let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; 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: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+                let __v_26: G = __loaded[0];
+                let __v_27: G = __loaded[1];
+                let __v_28: G = __loaded[2];
+                let __v_29: G = __loaded[3];
+                let __v_30: G = __loaded[4];
+                let __v_31: G = __loaded[5];
+                let __v_32: G = __loaded[6];
+                let __v_33: G = __loaded[7];
+                let __v_34: G = __loaded[8];
+                let __v_35: G = __loaded[9];
+                let __v_36: G = __loaded[10];
+                let __v_37: G = __loaded[11];
+                match __v_26.as_canonical_u64() {
+                  5u64 => {
+                    let __v_38: G = G::from_bool((__v_30 == G::ZERO));
+                    let __v_39: G = G::from_u64(1);
+                    let __v_40: G = (__v_31 - __v_39);
+                    let __v_41: G = G::from_bool((__v_40 == G::ZERO));
+                    let __v_42: G = (__v_38 * __v_41);
+                    match __v_42.as_canonical_u64() {
                       0u64 => {
-                        let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_6, __v_8, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[500].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_500] = unsafe { *(result.output.as_ptr() as *const [G; OUT_500]) }; __ret } else { aiur_fn_500(__args, record, io_buffer, __cu)? } };
-                        let __v_22: G = __r_arr[0];
-                        let __ret: [G; OUT_499] = [__v_22];
-                        record.function_queries[499].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __v_43: G = G::from_u64(0);
+                        let __ret: [G; OUT_408] = [__v_43];
+                        record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       _ => {
-                        let __v_22: G = G::from_u64(0);
-                        let __ret: [G; OUT_499] = [__v_22];
-                        record.function_queries[499].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                        return Ok(__ret);
+                        let __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[410].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_410] = unsafe { *(result.output.as_ptr() as *const [G; OUT_410]) }; __ret } else { aiur_fn_410(__args, record, io_buffer, __cu)? } };
+                        let __v_43: G = __r_arr[0];
+                        let __r_arr: [G; OUT_370] = { let __args: [G; IN_370] = [__v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[370].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_370] = unsafe { *(result.output.as_ptr() as *const [G; OUT_370]) }; __ret } else { aiur_fn_370(__args, record, io_buffer, __cu)? } };
+                        let __v_44: G = __r_arr[0];
+                        match __v_44.as_canonical_u64() {
+                          1u64 => {
+                            let __v_45: G = G::from_u64(0);
+                            let __ret: [G; OUT_408] = [__v_45];
+                            record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            return Ok(__ret);
+                          },
+                          _ => {
+                            let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[388].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_388] = unsafe { *(result.output.as_ptr() as *const [G; OUT_388]) }; __ret } else { aiur_fn_388(__args, record, io_buffer, __cu)? } };
+                            let __v_45: G = __r_arr[0];
+                            let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[388].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_388] = unsafe { *(result.output.as_ptr() as *const [G; OUT_388]) }; __ret } else { aiur_fn_388(__args, record, io_buffer, __cu)? } };
+                            let __v_46: G = __r_arr[0];
+                            let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_45, __v_46, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } };
+                            let __v_47: G = __r_arr[0];
+                            match __v_47.as_canonical_u64() {
+                              0u64 => {
+                                let __v_48: G = G::from_u64(0);
+                                let __ret: [G; OUT_408] = [__v_48];
+                                record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                return Ok(__ret);
+                              },
+                              _ => {
+                                let __v_48: G = G::from_u64(0);
+                                let __r_arr: [G; OUT_409] = { let __args: [G; IN_409] = [__v_43, __v_16, __v_17, __v_0, __v_4, __v_48, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[409].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_409] = unsafe { *(result.output.as_ptr() as *const [G; OUT_409]) }; __ret } else { aiur_fn_409(__args, record, io_buffer, __cu)? } };
+                                let __v_49: G = __r_arr[0];
+                                let __ret: [G; OUT_408] = [__v_49];
+                                record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                return Ok(__ret);
+                              },
+                            }
+                          },
+                        }
                       },
                     }
                   },
                   _ => {
-                    return Err(ExecError::MatchNoCase(__v_18.as_canonical_u64()));
+                    let __v_38: G = G::from_u64(0);
+                    let __ret: [G; OUT_408] = [__v_38];
+                    record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
                   },
                 }
               },
               _ => {
-                let __v_18: G = G::from_u64(0);
-                let __ret: [G; OUT_499] = [__v_18];
-                record.function_queries[499].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __v_25: G = G::from_u64(0);
+                let __ret: [G; OUT_408] = [__v_25];
+                record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
           _ => {
-            let __v_17: G = G::from_u64(0);
-            let __ret: [G; OUT_499] = [__v_17];
-            record.function_queries[499].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __v_22: G = G::from_u64(0);
+            let __ret: [G; OUT_408] = [__v_22];
+            record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
       _ => {
-        let __v_13: G = G::from_u64(0);
-        let __ret: [G; OUT_499] = [__v_13];
-        record.function_queries[499].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __v_9: G = G::from_u64(0);
+        let __ret: [G; OUT_408] = [__v_9];
+        record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_500: usize = 5;
-const IN_500: usize = 5;
-const OUT_500: usize = 1;
-fn aiur_fn_500(
-  inp: [G; IN_500],
+const INPUT_SIZE_409: usize = 7;
+const IN_409: usize = 7;
+const OUT_409: usize = 1;
+fn aiur_fn_409(
+  inp: [G; IN_409],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_500], ExecError> {
+) -> Result<[G; OUT_409], 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 __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_5: G = __loaded[0];
-    let __v_6: G = __loaded[1];
-    let __v_7: G = __loaded[2];
-    match __v_5.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_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_8: G = __loaded[0];
-        let __v_9: G = __loaded[1];
-        let __v_10: G = __loaded[2];
-        match __v_8.as_canonical_u64() {
-          1u64 => {
-            let __v_11: G = G::from_u64(1);
-            let __ret: [G; OUT_500] = [__v_11];
-            record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = (__v_2 - __v_5);
+    match __v_7.as_canonical_u64() {
+      0u64 => {
+        let __v_8: G = G::from_u64(1);
+        let __ret: [G; OUT_409] = [__v_8];
+        record.function_queries[409].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __v_8: G = G::from_u64(8);
+        let __v_9: G = { let __values: [G; 4] = [__v_8, __v_0, __v_5, __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 __v_10: G = (__v_1 + __v_5);
+        let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_4, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } };
+        let __v_11: G = __r_arr[0];
+        let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_9, __v_11, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } };
+        let __v_12: G = __r_arr[0];
+        match __v_12.as_canonical_u64() {
+          0u64 => {
+            let __v_13: G = G::from_u64(0);
+            let __ret: [G; OUT_409] = [__v_13];
+            record.function_queries[409].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __v_11: G = G::from_u64(0);
-            let __ret: [G; OUT_500] = [__v_11];
-            record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __v_13: G = G::from_u64(1);
+            let __v_14: G = (__v_5 + __v_13);
+            let __r_arr: [G; OUT_409] = { let __args: [G; IN_409] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_14, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[409].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_409] = unsafe { *(result.output.as_ptr() as *const [G; OUT_409]) }; __ret } else { aiur_fn_409(__args, record, io_buffer, __cu)? } };
+            let __v_15: G = __r_arr[0];
+            let __ret: [G; OUT_409] = [__v_15];
+            record.function_queries[409].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_8: G = __loaded[0];
-        let __v_9: G = __loaded[1];
-        let __v_10: G = __loaded[2];
-        match __v_8.as_canonical_u64() {
-          1u64 => {
+    }
+  })
+}
+
+const INPUT_SIZE_410: usize = 2;
+const IN_410: usize = 2;
+const OUT_410: usize = 1;
+fn aiur_fn_410(
+  inp: [G; IN_410],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_410], 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_265] = { let __args: [G; IN_265] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[265].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_265] = unsafe { *(result.output.as_ptr() as *const [G; OUT_265]) }; __ret } else { aiur_fn_265(__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 = G::from_u64(6);
+    let __v_11: G = G::from_u64(0);
+    let __v_12: G = G::from_u64(1);
+    let __v_13: G = G::from_u64(1);
+    let __v_14: G = { let __values: [G; 3] = [__v_12, __v_13, __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_15: G = G::from_u64(1);
+    let __v_16: G = G::from_u64(1);
+    let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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 = G::from_u64(1);
+    let __v_19: G = G::from_u64(1);
+    let __v_20: G = { let __values: [G; 3] = [__v_18, __v_19, __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 = G::from_u64(1);
+    let __v_22: G = G::from_u64(1);
+    let __v_23: G = { let __values: [G; 3] = [__v_21, __v_22, __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 __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_0, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_14, __v_17, __v_20, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[67].get_mut(&__args[..]) { 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_24: G = __r_arr[0];
+    let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[18].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_18] = unsafe { *(result.output.as_ptr() as *const [G; OUT_18]) }; __ret } else { aiur_fn_18(__args, record, io_buffer, __cu)? } };
+    let __v_25: G = __r_arr[0];
+    let __ret: [G; OUT_410] = [__v_25];
+    record.function_queries[410].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_411: usize = 3;
+const IN_411: usize = 3;
+const OUT_411: usize = 1;
+fn aiur_fn_411(
+  inp: [G; IN_411],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_411], 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; 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_3: G = __loaded[0];
+    let __v_4: G = __loaded[1];
+    let __v_5: G = __loaded[2];
+    let __v_6: G = __loaded[3];
+    match __v_3.as_canonical_u64() {
+      4u64 => {
+        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_7: G = __loaded[0];
+        let __v_8: G = __loaded[1];
+        let __v_9: G = __loaded[2];
+        let __v_10: G = __loaded[3];
+        match __v_7.as_canonical_u64() {
+          4u64 => {
             let __v_11: G = G::from_u64(0);
-            let __ret: [G; OUT_500] = [__v_11];
-            record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_411] = [__v_11];
+            record.function_queries[411].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
-          0u64 => {
-            let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_6, __v_9, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } };
+          _ => {
+            let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_4, __v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } };
             let __v_11: G = __r_arr[0];
-            match __v_11.as_canonical_u64() {
-              0u64 => {
-                let __v_12: G = G::from_u64(0);
-                let __ret: [G; OUT_500] = [__v_12];
-                record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              1u64 => {
-                let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_7, __v_10, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[500].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_500] = unsafe { *(result.output.as_ptr() as *const [G; OUT_500]) }; __ret } else { aiur_fn_500(__args, record, io_buffer, __cu)? } };
-                let __v_12: G = __r_arr[0];
-                let __ret: [G; OUT_500] = [__v_12];
-                record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              _ => {
-                return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64()));
-              },
-            }
+            let __ret: [G; OUT_411] = [__v_11];
+            record.function_queries[411].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+        }
+      },
+      _ => {
+        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_7: G = __loaded[0];
+        let __v_8: G = __loaded[1];
+        let __v_9: G = __loaded[2];
+        let __v_10: G = __loaded[3];
+        match __v_7.as_canonical_u64() {
+          4u64 => {
+            let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_8, __v_9, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } };
+            let __v_11: G = __r_arr[0];
+            let __ret: [G; OUT_411] = [__v_11];
+            record.function_queries[411].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
           },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64()));
+            let __v_11: G = G::from_u64(0);
+            let __ret: [G; OUT_411] = [__v_11];
+            record.function_queries[411].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
           },
         }
       },
+    }
+  })
+}
+
+const INPUT_SIZE_412: usize = 3;
+const IN_412: usize = 3;
+const OUT_412: usize = 1;
+fn aiur_fn_412(
+  inp: [G; IN_412],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_412], 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_388] = { let __args: [G; IN_388] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[388].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_388] = unsafe { *(result.output.as_ptr() as *const [G; OUT_388]) }; __ret } else { aiur_fn_388(__args, record, io_buffer, __cu)? } };
+    let __v_3: G = __r_arr[0];
+    let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_3, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = unsafe { *(result.output.as_ptr() as *const [G; OUT_377]) }; __ret } else { aiur_fn_377(__args, record, io_buffer, __cu)? } };
+    let __v_4: G = __r_arr[0];
+    let __r_arr: [G; OUT_413] = { let __args: [G; IN_413] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[413].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_413] = unsafe { *(result.output.as_ptr() as *const [G; OUT_413]) }; __ret } else { aiur_fn_413(__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(0);
+        let __ret: [G; OUT_412] = [__v_6];
+        record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
+        let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[388].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_388] = unsafe { *(result.output.as_ptr() as *const [G; OUT_388]) }; __ret } else { aiur_fn_388(__args, record, io_buffer, __cu)? } };
+        let __v_6: G = __r_arr[0];
+        let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_3, __v_6, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } };
+        let __v_7: G = __r_arr[0];
+        let __ret: [G; OUT_412] = [__v_7];
+        record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_501: usize = 2;
-const IN_501: usize = 2;
-const OUT_501: usize = 1;
-fn aiur_fn_501(
-  inp: [G; IN_501],
+const INPUT_SIZE_413: usize = 1;
+const IN_413: usize = 1;
+const OUT_413: usize = 1;
+fn aiur_fn_413(
+  inp: [G; IN_413],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_501], ExecError> {
+) -> Result<[G; OUT_413], 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_778] = { let __args: [G; IN_778] = [__v_1, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-    let __v_2: G = __r_arr[0];
-    let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr };
+    let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[106].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_106] = unsafe { *(result.output.as_ptr() as *const [G; OUT_106]) }; __ret } else { aiur_fn_106(__args, record, io_buffer, __cu)? } };
+    let __v_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    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_3: G = __loaded[0];
     let __v_4: G = __loaded[1];
     let __v_5: G = __loaded[2];
     let __v_6: G = __loaded[3];
-    let __v_7: G = __loaded[4];
-    let __v_8: G = __loaded[5];
-    let __v_9: G = __loaded[6];
-    let __v_10: G = __loaded[7];
-    let __v_11: G = __loaded[8];
-    let __v_12: G = __loaded[9];
-    let __v_13: G = __loaded[10];
     match __v_3.as_canonical_u64() {
-      1u64 => {
-        let __v_14: G = G::from_u64(1);
-        let __ret: [G; OUT_501] = [__v_14];
-        record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
       2u64 => {
-        let __v_14: G = G::from_u64(1);
-        let __ret: [G; OUT_501] = [__v_14];
-        record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
+        let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[258].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_258] = unsafe { *(result.output.as_ptr() as *const [G; OUT_258]) }; __ret } else { aiur_fn_258(__args, record, io_buffer, __cu)? } };
+        let __v_7: G = __r_arr[0];
+        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; 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: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].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];
+        let __v_18: G = __loaded[10];
+        let __v_19: G = __loaded[11];
+        match __v_8.as_canonical_u64() {
+          5u64 => {
+            let __v_20: G = G::from_u64(1);
+            let __v_21: G = (__v_13 - __v_20);
+            match __v_21.as_canonical_u64() {
+              0u64 => {
+                let __v_22: G = G::from_u64(0);
+                let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_15, __v_16, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[261].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_261] = unsafe { *(result.output.as_ptr() as *const [G; OUT_261]) }; __ret } else { aiur_fn_261(__args, record, io_buffer, __cu)? } };
+                let __v_23: G = __r_arr[0];
+                let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_23.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+                let __v_24: G = __loaded[0];
+                let __v_25: G = __loaded[1];
+                let __v_26: G = __loaded[2];
+                let __v_27: G = __loaded[3];
+                let __v_28: G = __loaded[4];
+                let __v_29: G = __loaded[5];
+                let __v_30: G = __loaded[6];
+                let __v_31: G = __loaded[7];
+                let __v_32: G = __loaded[8];
+                let __v_33: G = __loaded[9];
+                let __v_34: G = __loaded[10];
+                let __v_35: G = __loaded[11];
+                match __v_24.as_canonical_u64() {
+                  6u64 => {
+                    match __v_31.as_canonical_u64() {
+                      0u64 => {
+                        let __v_36: G = G::from_u64(1);
+                        let __ret: [G; OUT_413] = [__v_36];
+                        record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        return Ok(__ret);
+                      },
+                      _ => {
+                        let __v_36: G = G::from_u64(0);
+                        let __ret: [G; OUT_413] = [__v_36];
+                        record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        return Ok(__ret);
+                      },
+                    }
+                  },
+                  _ => {
+                    let __v_36: G = G::from_u64(0);
+                    let __ret: [G; OUT_413] = [__v_36];
+                    record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
+                  },
+                }
+              },
+              _ => {
+                let __v_22: G = G::from_u64(0);
+                let __ret: [G; OUT_413] = [__v_22];
+                record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+            }
+          },
+          _ => {
+            let __v_20: G = G::from_u64(0);
+            let __ret: [G; OUT_413] = [__v_20];
+            record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+        }
       },
       _ => {
-        let __v_14: G = G::from_u64(0);
-        let __ret: [G; OUT_501] = [__v_14];
-        record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __v_7: G = G::from_u64(0);
+        let __ret: [G; OUT_413] = [__v_7];
+        record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_502: usize = 2;
-const IN_502: usize = 2;
-const OUT_502: usize = 1;
-fn aiur_fn_502(
-  inp: [G; IN_502],
+const INPUT_SIZE_414: usize = 3;
+const IN_414: usize = 3;
+const OUT_414: usize = 1;
+fn aiur_fn_414(
+  inp: [G; IN_414],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_502], ExecError> {
+) -> Result<[G; OUT_414], 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_778] = { let __args: [G; IN_778] = [__v_1, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-    let __v_2: G = __r_arr[0];
-    let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr };
-    let __v_3: G = __loaded[0];
-    let __v_4: G = __loaded[1];
-    let __v_5: G = __loaded[2];
-    let __v_6: G = __loaded[3];
-    let __v_7: G = __loaded[4];
-    let __v_8: G = __loaded[5];
-    let __v_9: G = __loaded[6];
-    let __v_10: G = __loaded[7];
-    let __v_11: G = __loaded[8];
-    let __v_12: G = __loaded[9];
-    let __v_13: G = __loaded[10];
-    match __v_3.as_canonical_u64() {
-      1u64 => {
-        let __ret: [G; OUT_502] = [__v_8];
-        record.function_queries[502].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __v_2: G = inp[2];
+    let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[388].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_388] = unsafe { *(result.output.as_ptr() as *const [G; OUT_388]) }; __ret } else { aiur_fn_388(__args, record, io_buffer, __cu)? } };
+    let __v_3: G = __r_arr[0];
+    let __r_arr: [G; OUT_416] = { let __args: [G; IN_416] = [__v_3, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[416].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_416] = unsafe { *(result.output.as_ptr() as *const [G; OUT_416]) }; __ret } else { aiur_fn_416(__args, record, io_buffer, __cu)? } };
+    let __v_4: G = __r_arr[0];
+    match __v_4.as_canonical_u64() {
+      0u64 => {
+        let __v_5: G = G::from_u64(0);
+        let __ret: [G; OUT_414] = [__v_5];
+        record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __v_14: G = G::from_u64(0);
-        let __ret: [G; OUT_502] = [__v_14];
-        record.function_queries[502].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[388].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_388] = unsafe { *(result.output.as_ptr() as *const [G; OUT_388]) }; __ret } else { aiur_fn_388(__args, record, io_buffer, __cu)? } };
+        let __v_5: G = __r_arr[0];
+        let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_3, __v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } };
+        let __v_6: G = __r_arr[0];
+        let __ret: [G; OUT_414] = [__v_6];
+        record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_503: usize = 2;
-const IN_503: usize = 2;
-const OUT_503: usize = 2;
-fn aiur_fn_503(
-  inp: [G; IN_503],
+const INPUT_SIZE_415: usize = 4;
+const IN_415: usize = 4;
+const OUT_415: usize = 1;
+fn aiur_fn_415(
+  inp: [G; IN_415],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_503], ExecError> {
+) -> Result<[G; OUT_415], 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_189] = { let __args: [G; IN_189] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[189].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_189] = unsafe { *(result.output.as_ptr() as *const [G; OUT_189]) }; __ret } else { aiur_fn_189(__args, record, io_buffer, __cu)? } };
-    let __v_2: G = __r_arr[0];
-    let __v_3: G = __r_arr[1];
-    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_4: G = __loaded[0];
-    let __v_5: G = __loaded[1];
-    let __v_6: G = __loaded[2];
-    let __v_7: G = __loaded[3];
-    match __v_4.as_canonical_u64() {
-      2u64 => {
-        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-        let __v_8: G = __r_arr[0];
-        let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].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 __v_17: G = __loaded[8];
-        let __v_18: G = __loaded[9];
-        let __v_19: G = __loaded[10];
-        match __v_9.as_canonical_u64() {
-          1u64 => {
-            let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_12, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } };
-            let __v_20: G = __r_arr[0];
-            let __v_21: G = G::from_u64(1);
-            let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_20, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[427].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_427] = unsafe { *(result.output.as_ptr() as *const [G; OUT_427]) }; __ret } else { aiur_fn_427(__args, record, io_buffer, __cu)? } };
-            let __v_22: G = __r_arr[0];
-            let __ret: [G; OUT_503] = [__v_21, __v_22];
-            record.function_queries[503].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          2u64 => {
-            let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_12, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } };
-            let __v_20: G = __r_arr[0];
-            let __v_21: G = G::from_u64(1);
-            let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_20, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[427].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_427] = unsafe { *(result.output.as_ptr() as *const [G; OUT_427]) }; __ret } else { aiur_fn_427(__args, record, io_buffer, __cu)? } };
-            let __v_22: G = __r_arr[0];
-            let __ret: [G; OUT_503] = [__v_21, __v_22];
-            record.function_queries[503].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            let __v_20: G = G::from_u64(0);
-            let __ret: [G; OUT_503] = [__v_20, __v_0];
-            record.function_queries[503].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-        }
-      },
-      _ => {
-        let __v_8: G = G::from_u64(0);
-        let __ret: [G; OUT_503] = [__v_8, __v_0];
-        record.function_queries[503].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-    }
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = G::from_u64(1);
+    let __v_5: G = G::from_u64(0);
+    let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_2, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[325].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_325] = unsafe { *(result.output.as_ptr() as *const [G; OUT_325]) }; __ret } else { aiur_fn_325(__args, record, io_buffer, __cu)? } };
+    let __v_6: G = __r_arr[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 = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_9]; 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_11: G = G::from_u64(3);
+    let __v_12: G = G::from_u64(0);
+    let __v_13: G = { let __values: [G; 4] = [__v_11, __v_6, __v_10, __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 __v_14: G = G::from_u64(0);
+    let __v_15: G = { let __values: [G; 3] = [__v_14, __v_0, __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_394] = { let __args: [G; IN_394] = [__v_1, __v_13, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } };
+    let __v_16: G = __r_arr[0];
+    let __ret: [G; OUT_415] = [__v_16];
+    record.function_queries[415].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_504: usize = 2;
-const IN_504: usize = 2;
-const OUT_504: usize = 2;
-fn aiur_fn_504(
-  inp: [G; IN_504],
+const INPUT_SIZE_416: usize = 2;
+const IN_416: usize = 2;
+const OUT_416: usize = 1;
+fn aiur_fn_416(
+  inp: [G; IN_416],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_504], ExecError> {
+) -> Result<[G; OUT_416], 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_189] = { let __args: [G; IN_189] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[189].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_189] = unsafe { *(result.output.as_ptr() as *const [G; OUT_189]) }; __ret } else { aiur_fn_189(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[388].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_388] = unsafe { *(result.output.as_ptr() as *const [G; OUT_388]) }; __ret } else { aiur_fn_388(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
-    let __v_3: G = __r_arr[1];
-    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 __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = unsafe { *(result.output.as_ptr() as *const [G; OUT_377]) }; __ret } else { aiur_fn_377(__args, record, io_buffer, __cu)? } };
+    let __v_3: 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_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: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_4: G = __loaded[0];
     let __v_5: G = __loaded[1];
     let __v_6: G = __loaded[2];
     let __v_7: G = __loaded[3];
     match __v_4.as_canonical_u64() {
-      8u64 => {
-        let __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[503].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_503] = unsafe { *(result.output.as_ptr() as *const [G; OUT_503]) }; __ret } else { aiur_fn_503(__args, record, io_buffer, __cu)? } };
-        let __v_8: G = __r_arr[0];
-        let __v_9: G = __r_arr[1];
+      1u64 => {
+        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_8: G = __loaded[0];
+        let __v_9: G = __loaded[1];
+        let __v_10: G = __loaded[2];
         match __v_8.as_canonical_u64() {
-          1u64 => {
-            let __v_10: G = G::from_u64(8);
-            let __v_11: G = { let __values: [G; 4] = [__v_10, __v_5, __v_6, __v_9]; 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_12: G = G::from_u64(1);
-            let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[427].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_427] = unsafe { *(result.output.as_ptr() as *const [G; OUT_427]) }; __ret } else { aiur_fn_427(__args, record, io_buffer, __cu)? } };
-            let __v_13: G = __r_arr[0];
-            let __ret: [G; OUT_504] = [__v_12, __v_13];
-            record.function_queries[504].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
           0u64 => {
-            let __v_10: G = G::from_u64(0);
-            let __ret: [G; OUT_504] = [__v_10, __v_0];
-            record.function_queries[504].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __v_11: G = G::from_u64(1);
+            let __ret: [G; OUT_416] = [__v_11];
+            record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64()));
+            let __v_11: G = G::from_u64(0);
+            let __ret: [G; OUT_416] = [__v_11];
+            record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
           },
         }
       },
       _ => {
         let __v_8: G = G::from_u64(0);
-        let __ret: [G; OUT_504] = [__v_8, __v_0];
-        record.function_queries[504].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_416] = [__v_8];
+        record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_505: usize = 6;
-const IN_505: usize = 6;
-const OUT_505: usize = 2;
-fn aiur_fn_505(
-  inp: [G; IN_505],
+const INPUT_SIZE_417: usize = 3;
+const IN_417: usize = 3;
+const OUT_417: usize = 1;
+fn aiur_fn_417(
+  inp: [G; IN_417],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_505], ExecError> {
+) -> Result<[G; OUT_417], 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];
-    match __v_2.as_canonical_u64() {
-      0u64 => {
-        let __v_6: G = G::from_u64(0);
-        let __v_7: G = G::from_u64(0);
-        let __ret: [G; OUT_505] = [__v_6, __v_7];
-        record.function_queries[505].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        let __v_6: G = (__v_0 - __v_1);
-        match __v_6.as_canonical_u64() {
-          0u64 => {
-            let __v_7: G = G::from_u64(1);
-            let __v_8: G = G::from_u64(1);
-            let __ret: [G; OUT_505] = [__v_7, __v_8];
-            record.function_queries[505].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[189].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_189] = unsafe { *(result.output.as_ptr() as *const [G; OUT_189]) }; __ret } else { aiur_fn_189(__args, record, io_buffer, __cu)? } };
-            let __v_7: G = __r_arr[0];
-            let __v_8: G = __r_arr[1];
-            let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[189].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_189] = unsafe { *(result.output.as_ptr() as *const [G; OUT_189]) }; __ret } else { aiur_fn_189(__args, record, io_buffer, __cu)? } };
-            let __v_9: G = __r_arr[0];
-            let __v_10: G = __r_arr[1];
-            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; 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: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].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];
-            match __v_11.as_canonical_u64() {
-              2u64 => {
-                let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; 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: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
-                let __v_15: G = __loaded[0];
-                let __v_16: G = __loaded[1];
-                let __v_17: G = __loaded[2];
-                let __v_18: G = __loaded[3];
-                match __v_15.as_canonical_u64() {
-                  2u64 => {
-                    let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = [__v_12, __v_13, __v_8, __v_16, __v_17, __v_10, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[506].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_506] = unsafe { *(result.output.as_ptr() as *const [G; OUT_506]) }; __ret } else { aiur_fn_506(__args, record, io_buffer, __cu)? } };
-                    let __v_19: G = __r_arr[0];
-                    match __v_19.as_canonical_u64() {
-                      1u64 => {
-                        let __v_20: G = G::from_u64(1);
-                        let __v_21: G = G::from_u64(1);
-                        let __ret: [G; OUT_505] = [__v_20, __v_21];
-                        record.function_queries[505].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                        return Ok(__ret);
-                      },
-                      _ => {
-                        let __r_arr: [G; OUT_507] = { let __args: [G; IN_507] = [__v_12, __v_16, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[507].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_507] = unsafe { *(result.output.as_ptr() as *const [G; OUT_507]) }; __ret } else { aiur_fn_507(__args, record, io_buffer, __cu)? } };
-                        let __v_20: G = __r_arr[0];
-                        let __v_21: G = __r_arr[1];
-                        let __ret: [G; OUT_505] = [__v_20, __v_21];
-                        record.function_queries[505].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                        return Ok(__ret);
-                      },
-                    }
-                  },
-                  _ => {
-                    let __r_arr: [G; OUT_508] = { let __args: [G; IN_508] = [__v_12, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[508].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_508] = unsafe { *(result.output.as_ptr() as *const [G; OUT_508]) }; __ret } else { aiur_fn_508(__args, record, io_buffer, __cu)? } };
-                    let __v_19: G = __r_arr[0];
-                    let __v_20: G = __r_arr[1];
-                    let __ret: [G; OUT_505] = [__v_19, __v_20];
-                    record.function_queries[505].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
-                }
-              },
-              _ => {
-                let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; 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: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
-                let __v_15: G = __loaded[0];
-                let __v_16: G = __loaded[1];
-                let __v_17: G = __loaded[2];
-                let __v_18: G = __loaded[3];
-                match __v_15.as_canonical_u64() {
-                  2u64 => {
-                    let __r_arr: [G; OUT_509] = { let __args: [G; IN_509] = [__v_16, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[509].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_509] = unsafe { *(result.output.as_ptr() as *const [G; OUT_509]) }; __ret } else { aiur_fn_509(__args, record, io_buffer, __cu)? } };
-                    let __v_19: G = __r_arr[0];
-                    let __v_20: G = __r_arr[1];
-                    let __ret: [G; OUT_505] = [__v_19, __v_20];
-                    record.function_queries[505].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
-                  _ => {
-                    let __v_19: G = G::from_u64(0);
-                    let __v_20: G = G::from_u64(0);
-                    let __ret: [G; OUT_505] = [__v_19, __v_20];
-                    record.function_queries[505].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
-                }
-              },
-            }
-          },
-        }
-      },
-    }
+    let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } else { aiur_fn_418(__args, record, io_buffer, __cu)? } };
+    let __v_3: G = __r_arr[0];
+    let __ret: [G; OUT_417] = [__v_3];
+    record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_506: usize = 9;
-const IN_506: usize = 9;
-const OUT_506: usize = 1;
-fn aiur_fn_506(
-  inp: [G; IN_506],
+const INPUT_SIZE_418: usize = 3;
+const IN_418: usize = 3;
+const OUT_418: usize = 1;
+fn aiur_fn_418(
+  inp: [G; IN_418],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_506], ExecError> {
+) -> Result<[G; OUT_418], 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 = (__v_0 - __v_3);
-    match __v_9.as_canonical_u64() {
+    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_3: G = __loaded[0];
+    let __v_4: G = __loaded[1];
+    let __v_5: G = __loaded[2];
+    let __v_6: G = __loaded[3];
+    match __v_3.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[498].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_498] = unsafe { *(result.output.as_ptr() as *const [G; OUT_498]) }; __ret } else { aiur_fn_498(__args, record, io_buffer, __cu)? } };
-        let __v_10: G = __r_arr[0];
-        match __v_10.as_canonical_u64() {
+        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_7: G = __loaded[0];
+        let __v_8: G = __loaded[1];
+        let __v_9: G = __loaded[2];
+        let __v_10: G = __loaded[3];
+        match __v_7.as_canonical_u64() {
           0u64 => {
-            let __v_11: G = G::from_u64(0);
-            let __ret: [G; OUT_506] = [__v_11];
-            record.function_queries[506].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          1u64 => {
-            let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { 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_11: G = __r_arr[0];
-            let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { 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_12: G = __r_arr[0];
-            let __v_13: G = (__v_11 - __v_12);
-            match __v_13.as_canonical_u64() {
+            let __v_11: G = (__v_4 - __v_8);
+            match __v_11.as_canonical_u64() {
               0u64 => {
-                let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_2, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[500].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_500] = unsafe { *(result.output.as_ptr() as *const [G; OUT_500]) }; __ret } else { aiur_fn_500(__args, record, io_buffer, __cu)? } };
-                let __v_14: G = __r_arr[0];
-                let __ret: [G; OUT_506] = [__v_14];
-                record.function_queries[506].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __v_12: G = G::from_u64(1);
+                let __ret: [G; OUT_418] = [__v_12];
+                record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                let __v_14: G = G::from_u64(0);
-                let __ret: [G; OUT_506] = [__v_14];
-                record.function_queries[506].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __v_12: G = G::from_u64(0);
+                let __ret: [G; OUT_418] = [__v_12];
+                record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64()));
-          },
-        }
-      },
-      _ => {
-        let __v_10: G = G::from_u64(0);
-        let __ret: [G; OUT_506] = [__v_10];
-        record.function_queries[506].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_507: usize = 8;
-const IN_507: usize = 8;
-const OUT_507: usize = 2;
-fn aiur_fn_507(
-  inp: [G; IN_507],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_507], 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 __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[501].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_501] = unsafe { *(result.output.as_ptr() as *const [G; OUT_501]) }; __ret } else { aiur_fn_501(__args, record, io_buffer, __cu)? } };
-    let __v_8: G = __r_arr[0];
-    let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[501].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_501] = unsafe { *(result.output.as_ptr() as *const [G; OUT_501]) }; __ret } else { aiur_fn_501(__args, record, io_buffer, __cu)? } };
-    let __v_9: G = __r_arr[0];
-    match __v_8.as_canonical_u64() {
-      0u64 => {
-        match __v_9.as_canonical_u64() {
-          0u64 => {
-            let __v_10: G = G::from_u64(0);
             let __v_11: G = G::from_u64(0);
-            let __ret: [G; OUT_507] = [__v_10, __v_11];
-            record.function_queries[507].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_418] = [__v_11];
+            record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
+        }
+      },
+      1u64 => {
+        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_7: G = __loaded[0];
+        let __v_8: G = __loaded[1];
+        let __v_9: G = __loaded[2];
+        let __v_10: G = __loaded[3];
+        match __v_7.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_511] = { let __args: [G; IN_511] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[511].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_511] = unsafe { *(result.output.as_ptr() as *const [G; OUT_511]) }; __ret } else { aiur_fn_511(__args, record, io_buffer, __cu)? } };
-            let __v_10: G = __r_arr[0];
-            let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_507] = [__v_10, __v_11];
-            record.function_queries[507].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } else { aiur_fn_295(__args, record, io_buffer, __cu)? } };
+            let __v_11: G = __r_arr[0];
+            let __ret: [G; OUT_418] = [__v_11];
+            record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __v_10: G = G::from_u64(0);
             let __v_11: G = G::from_u64(0);
-            let __ret: [G; OUT_507] = [__v_10, __v_11];
-            record.function_queries[507].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_418] = [__v_11];
+            record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
-      1u64 => {
-        match __v_9.as_canonical_u64() {
-          0u64 => {
-            let __r_arr: [G; OUT_510] = { let __args: [G; IN_510] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[510].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_510] = unsafe { *(result.output.as_ptr() as *const [G; OUT_510]) }; __ret } else { aiur_fn_510(__args, record, io_buffer, __cu)? } };
-            let __v_10: G = __r_arr[0];
-            let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_507] = [__v_10, __v_11];
-            record.function_queries[507].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          1u64 => {
-            let __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[502].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_502] = unsafe { *(result.output.as_ptr() as *const [G; OUT_502]) }; __ret } else { aiur_fn_502(__args, record, io_buffer, __cu)? } };
-            let __v_10: G = __r_arr[0];
-            let __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[502].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_502] = unsafe { *(result.output.as_ptr() as *const [G; OUT_502]) }; __ret } else { aiur_fn_502(__args, record, io_buffer, __cu)? } };
+      2u64 => {
+        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_7: G = __loaded[0];
+        let __v_8: G = __loaded[1];
+        let __v_9: G = __loaded[2];
+        let __v_10: G = __loaded[3];
+        match __v_7.as_canonical_u64() {
+          2u64 => {
+            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_11: G = __r_arr[0];
-            let __v_12: G = { let __a_val = __v_11.as_canonical_u64(); let __b_val = __v_10.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_12.as_canonical_u64() {
+            match __v_11.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_510] = { let __args: [G; IN_510] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[510].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_510] = unsafe { *(result.output.as_ptr() as *const [G; OUT_510]) }; __ret } else { aiur_fn_510(__args, record, io_buffer, __cu)? } };
-                let __v_13: G = __r_arr[0];
-                let __v_14: G = __r_arr[1];
-                let __ret: [G; OUT_507] = [__v_13, __v_14];
-                record.function_queries[507].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[393].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_393] = unsafe { *(result.output.as_ptr() as *const [G; OUT_393]) }; __ret } else { aiur_fn_393(__args, record, io_buffer, __cu)? } };
+                let __v_12: G = __r_arr[0];
+                let __ret: [G; OUT_418] = [__v_12];
+                record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[431].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_431] = unsafe { *(result.output.as_ptr() as *const [G; OUT_431]) }; __ret } else { aiur_fn_431(__args, record, io_buffer, __cu)? } };
+                let __v_12: G = __r_arr[0];
+                let __ret: [G; OUT_418] = [__v_12];
+                record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
+            }
+          },
+          _ => {
+            let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[431].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_431] = unsafe { *(result.output.as_ptr() as *const [G; OUT_431]) }; __ret } else { aiur_fn_431(__args, record, io_buffer, __cu)? } };
+            let __v_11: G = __r_arr[0];
+            let __ret: [G; OUT_418] = [__v_11];
+            record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+        }
+      },
+      3u64 => {
+        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_7: G = __loaded[0];
+        let __v_8: G = __loaded[1];
+        let __v_9: G = __loaded[2];
+        let __v_10: G = __loaded[3];
+        match __v_7.as_canonical_u64() {
+          3u64 => {
+            let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } };
+            let __v_11: G = __r_arr[0];
+            match __v_11.as_canonical_u64() {
               0u64 => {
-                let __v_13: G = { let __a_val = __v_10.as_canonical_u64(); let __b_val = __v_11.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_13.as_canonical_u64() {
-                  1u64 => {
-                    let __r_arr: [G; OUT_511] = { let __args: [G; IN_511] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[511].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_511] = unsafe { *(result.output.as_ptr() as *const [G; OUT_511]) }; __ret } else { aiur_fn_511(__args, record, io_buffer, __cu)? } };
-                    let __v_14: G = __r_arr[0];
-                    let __v_15: G = __r_arr[1];
-                    let __ret: [G; OUT_507] = [__v_14, __v_15];
-                    record.function_queries[507].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
+                let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[431].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_431] = unsafe { *(result.output.as_ptr() as *const [G; OUT_431]) }; __ret } else { aiur_fn_431(__args, record, io_buffer, __cu)? } };
+                let __v_12: G = __r_arr[0];
+                let __ret: [G; OUT_418] = [__v_12];
+                record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_5, __v_9, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } };
+                let __v_12: G = __r_arr[0];
+                match __v_12.as_canonical_u64() {
                   0u64 => {
-                    let __r_arr: [G; OUT_512] = { let __args: [G; IN_512] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[512].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_512] = unsafe { *(result.output.as_ptr() as *const [G; OUT_512]) }; __ret } else { aiur_fn_512(__args, record, io_buffer, __cu)? } };
-                    let __v_14: G = __r_arr[0];
-                    let __v_15: G = __r_arr[1];
-                    let __ret: [G; OUT_507] = [__v_14, __v_15];
-                    record.function_queries[507].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[431].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_431] = unsafe { *(result.output.as_ptr() as *const [G; OUT_431]) }; __ret } else { aiur_fn_431(__args, record, io_buffer, __cu)? } };
+                    let __v_13: G = __r_arr[0];
+                    let __ret: [G; OUT_418] = [__v_13];
+                    record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
-                    return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64()));
+                    let __v_13: G = G::from_u64(1);
+                    let __ret: [G; OUT_418] = [__v_13];
+                    record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
                   },
                 }
               },
-              _ => {
-                return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64()));
-              },
             }
           },
           _ => {
-            let __v_10: G = G::from_u64(0);
-            let __v_11: G = G::from_u64(0);
-            let __ret: [G; OUT_507] = [__v_10, __v_11];
-            record.function_queries[507].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[431].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_431] = unsafe { *(result.output.as_ptr() as *const [G; OUT_431]) }; __ret } else { aiur_fn_431(__args, record, io_buffer, __cu)? } };
+            let __v_11: G = __r_arr[0];
+            let __ret: [G; OUT_418] = [__v_11];
+            record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
-      _ => {
-        let __v_10: G = G::from_u64(0);
-        let __v_11: G = G::from_u64(0);
-        let __ret: [G; OUT_507] = [__v_10, __v_11];
-        record.function_queries[507].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_508: usize = 7;
-const IN_508: usize = 7;
-const OUT_508: usize = 2;
-fn aiur_fn_508(
-  inp: [G; IN_508],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_508], 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 __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[501].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_501] = unsafe { *(result.output.as_ptr() as *const [G; OUT_501]) }; __ret } else { aiur_fn_501(__args, record, io_buffer, __cu)? } };
-    let __v_7: G = __r_arr[0];
-    match __v_7.as_canonical_u64() {
-      0u64 => {
-        let __v_8: G = G::from_u64(0);
-        let __v_9: G = G::from_u64(0);
-        let __ret: [G; OUT_508] = [__v_8, __v_9];
-        record.function_queries[508].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      1u64 => {
-        let __r_arr: [G; OUT_504] = { let __args: [G; IN_504] = [__v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[504].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_504] = unsafe { *(result.output.as_ptr() as *const [G; OUT_504]) }; __ret } else { aiur_fn_504(__args, record, io_buffer, __cu)? } };
-        let __v_8: G = __r_arr[0];
-        let __v_9: G = __r_arr[1];
-        match __v_8.as_canonical_u64() {
-          1u64 => {
-            let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_9, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } };
-            let __v_10: G = __r_arr[0];
-            let __v_11: G = G::from_u64(1);
-            let __v_12: G = (__v_3 - __v_11);
-            let __r_arr: [G; OUT_505] = { let __args: [G; IN_505] = [__v_1, __v_10, __v_12, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[505].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_505] = unsafe { *(result.output.as_ptr() as *const [G; OUT_505]) }; __ret } else { aiur_fn_505(__args, record, io_buffer, __cu)? } };
-            let __v_13: G = __r_arr[0];
-            let __v_14: G = __r_arr[1];
-            let __ret: [G; OUT_508] = [__v_13, __v_14];
-            record.function_queries[508].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
+      4u64 => {
+        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_7: G = __loaded[0];
+        let __v_8: G = __loaded[1];
+        let __v_9: G = __loaded[2];
+        let __v_10: G = __loaded[3];
+        match __v_7.as_canonical_u64() {
+          4u64 => {
+            let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } };
+            let __v_11: G = __r_arr[0];
+            match __v_11.as_canonical_u64() {
+              0u64 => {
+                let __v_12: G = G::from_u64(0);
+                let __ret: [G; OUT_418] = [__v_12];
+                record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                let __v_12: G = G::from_u64(0);
+                let __v_13: G = { let __values: [G; 3] = [__v_12, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_394] = { let __args: [G; IN_394] = [__v_5, __v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } };
+                let __v_14: G = __r_arr[0];
+                let __ret: [G; OUT_418] = [__v_14];
+                record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+            }
           },
-          0u64 => {
-            let __r_arr: [G; OUT_510] = { let __args: [G; IN_510] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[510].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_510] = unsafe { *(result.output.as_ptr() as *const [G; OUT_510]) }; __ret } else { aiur_fn_510(__args, record, io_buffer, __cu)? } };
-            let __v_10: G = __r_arr[0];
-            let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_508] = [__v_10, __v_11];
-            record.function_queries[508].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+          _ => {
+            let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_4, __v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } };
+            let __v_11: G = __r_arr[0];
+            let __ret: [G; OUT_418] = [__v_11];
+            record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
+        }
+      },
+      5u64 => {
+        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_7: G = __loaded[0];
+        let __v_8: G = __loaded[1];
+        let __v_9: G = __loaded[2];
+        let __v_10: G = __loaded[3];
+        match __v_7.as_canonical_u64() {
+          5u64 => {
+            let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } };
+            let __v_11: G = __r_arr[0];
+            match __v_11.as_canonical_u64() {
+              0u64 => {
+                let __v_12: G = G::from_u64(0);
+                let __ret: [G; OUT_418] = [__v_12];
+                record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                let __v_12: G = G::from_u64(0);
+                let __v_13: G = { let __values: [G; 3] = [__v_12, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_394] = { let __args: [G; IN_394] = [__v_5, __v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } };
+                let __v_14: G = __r_arr[0];
+                let __ret: [G; OUT_418] = [__v_14];
+                record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+            }
+          },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64()));
+            let __v_11: G = G::from_u64(0);
+            let __ret: [G; OUT_418] = [__v_11];
+            record.function_queries[418].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(0);
-        let __ret: [G; OUT_508] = [__v_8, __v_9];
-        record.function_queries[508].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_509: usize = 7;
-const IN_509: usize = 7;
-const OUT_509: usize = 2;
-fn aiur_fn_509(
-  inp: [G; IN_509],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_509], 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 __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[501].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_501] = unsafe { *(result.output.as_ptr() as *const [G; OUT_501]) }; __ret } else { aiur_fn_501(__args, record, io_buffer, __cu)? } };
-    let __v_7: G = __r_arr[0];
-    match __v_7.as_canonical_u64() {
-      0u64 => {
-        let __v_8: G = G::from_u64(0);
-        let __v_9: G = G::from_u64(0);
-        let __ret: [G; OUT_509] = [__v_8, __v_9];
-        record.function_queries[509].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+      6u64 => {
+        let __v_7: G = G::from_u64(0);
+        let __ret: [G; OUT_418] = [__v_7];
+        record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      1u64 => {
-        let __r_arr: [G; OUT_504] = { let __args: [G; IN_504] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[504].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_504] = unsafe { *(result.output.as_ptr() as *const [G; OUT_504]) }; __ret } else { aiur_fn_504(__args, record, io_buffer, __cu)? } };
-        let __v_8: G = __r_arr[0];
-        let __v_9: G = __r_arr[1];
-        match __v_8.as_canonical_u64() {
-          1u64 => {
-            let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_9, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } };
-            let __v_10: G = __r_arr[0];
-            let __v_11: G = G::from_u64(1);
-            let __v_12: G = (__v_3 - __v_11);
-            let __r_arr: [G; OUT_505] = { let __args: [G; IN_505] = [__v_10, __v_2, __v_12, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[505].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_505] = unsafe { *(result.output.as_ptr() as *const [G; OUT_505]) }; __ret } else { aiur_fn_505(__args, record, io_buffer, __cu)? } };
-            let __v_13: G = __r_arr[0];
-            let __v_14: G = __r_arr[1];
-            let __ret: [G; OUT_509] = [__v_13, __v_14];
-            record.function_queries[509].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          0u64 => {
-            let __r_arr: [G; OUT_511] = { let __args: [G; IN_511] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[511].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_511] = unsafe { *(result.output.as_ptr() as *const [G; OUT_511]) }; __ret } else { aiur_fn_511(__args, record, io_buffer, __cu)? } };
-            let __v_10: G = __r_arr[0];
-            let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_509] = [__v_10, __v_11];
-            record.function_queries[509].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+      7u64 => {
+        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_7: G = __loaded[0];
+        let __v_8: G = __loaded[1];
+        let __v_9: G = __loaded[2];
+        let __v_10: G = __loaded[3];
+        match __v_7.as_canonical_u64() {
+          7u64 => {
+            let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_4, __v_5, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[311].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_311] = unsafe { *(result.output.as_ptr() as *const [G; OUT_311]) }; __ret } else { aiur_fn_311(__args, record, io_buffer, __cu)? } };
+            let __v_11: G = __r_arr[0];
+            let __ret: [G; OUT_418] = [__v_11];
+            record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64()));
+            let __r_arr: [G; OUT_360] = { let __args: [G; IN_360] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[360].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_360] = unsafe { *(result.output.as_ptr() as *const [G; OUT_360]) }; __ret } else { aiur_fn_360(__args, record, io_buffer, __cu)? } };
+            let __v_11: G = __r_arr[0];
+            let __v_12: G = (__v_11 - __v_0);
+            match __v_12.as_canonical_u64() {
+              0u64 => {
+                let __v_13: G = G::from_u64(0);
+                let __ret: [G; OUT_418] = [__v_13];
+                record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_11, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } else { aiur_fn_418(__args, record, io_buffer, __cu)? } };
+                let __v_13: G = __r_arr[0];
+                let __ret: [G; OUT_418] = [__v_13];
+                record.function_queries[418].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(0);
-        let __ret: [G; OUT_509] = [__v_8, __v_9];
-        record.function_queries[509].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_510: usize = 6;
-const IN_510: usize = 6;
-const OUT_510: usize = 2;
-fn aiur_fn_510(
-  inp: [G; IN_510],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_510], 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_503] = { let __args: [G; IN_503] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[503].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_503] = unsafe { *(result.output.as_ptr() as *const [G; OUT_503]) }; __ret } else { aiur_fn_503(__args, record, io_buffer, __cu)? } };
-    let __v_6: G = __r_arr[0];
-    let __v_7: G = __r_arr[1];
-    match __v_6.as_canonical_u64() {
-      1u64 => {
-        let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_7, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } else { aiur_fn_439(__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_2 - __v_9);
-        let __r_arr: [G; OUT_505] = { let __args: [G; IN_505] = [__v_8, __v_1, __v_10, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[505].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_505] = unsafe { *(result.output.as_ptr() as *const [G; OUT_505]) }; __ret } else { aiur_fn_505(__args, record, io_buffer, __cu)? } };
-        let __v_11: G = __r_arr[0];
-        let __v_12: G = __r_arr[1];
-        let __ret: [G; OUT_510] = [__v_11, __v_12];
-        record.function_queries[510].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __v_8: G = G::from_u64(0);
-        let __v_9: G = G::from_u64(0);
-        let __ret: [G; OUT_510] = [__v_8, __v_9];
-        record.function_queries[510].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
+      8u64 => {
+        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_7: G = __loaded[0];
+        let __v_8: G = __loaded[1];
+        let __v_9: G = __loaded[2];
+        let __v_10: G = __loaded[3];
+        match __v_7.as_canonical_u64() {
+          8u64 => {
+            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_11: G = __r_arr[0];
+            match __v_11.as_canonical_u64() {
+              1u64 => {
+                let __v_12: G = (__v_5 - __v_9);
+                match __v_12.as_canonical_u64() {
+                  0u64 => {
+                    let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_6, __v_10, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } };
+                    let __v_13: G = __r_arr[0];
+                    let __ret: [G; OUT_418] = [__v_13];
+                    record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
+                  },
+                  _ => {
+                    let __v_13: G = G::from_u64(0);
+                    let __ret: [G; OUT_418] = [__v_13];
+                    record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
+                  },
+                }
+              },
+              _ => {
+                let __v_12: G = G::from_u64(0);
+                let __ret: [G; OUT_418] = [__v_12];
+                record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+            }
+          },
+          _ => {
+            let __v_11: G = G::from_u64(0);
+            let __ret: [G; OUT_418] = [__v_11];
+            record.function_queries[418].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_511: usize = 6;
-const IN_511: usize = 6;
-const OUT_511: usize = 2;
-fn aiur_fn_511(
-  inp: [G; IN_511],
+const INPUT_SIZE_419: usize = 4;
+const IN_419: usize = 4;
+const OUT_419: usize = 1;
+fn aiur_fn_419(
+  inp: [G; IN_419],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_511], ExecError> {
+) -> Result<[G; OUT_419], 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_503] = { let __args: [G; IN_503] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[503].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_503] = unsafe { *(result.output.as_ptr() as *const [G; OUT_503]) }; __ret } else { aiur_fn_503(__args, record, io_buffer, __cu)? } };
-    let __v_6: G = __r_arr[0];
-    let __v_7: G = __r_arr[1];
-    match __v_6.as_canonical_u64() {
-      1u64 => {
-        let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_7, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } else { aiur_fn_439(__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_2 - __v_9);
-        let __r_arr: [G; OUT_505] = { let __args: [G; IN_505] = [__v_0, __v_8, __v_10, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[505].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_505] = unsafe { *(result.output.as_ptr() as *const [G; OUT_505]) }; __ret } else { aiur_fn_505(__args, record, io_buffer, __cu)? } };
-        let __v_11: G = __r_arr[0];
-        let __v_12: G = __r_arr[1];
-        let __ret: [G; OUT_511] = [__v_11, __v_12];
-        record.function_queries[511].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
+    match __v_2.as_canonical_u64() {
       0u64 => {
-        let __v_8: G = G::from_u64(0);
-        let __v_9: G = G::from_u64(0);
-        let __ret: [G; OUT_511] = [__v_8, __v_9];
-        record.function_queries[511].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __v_4: G = G::from_u64(0);
+        let __ret: [G; OUT_419] = [__v_4];
+        record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_512: usize = 6;
-const IN_512: usize = 6;
-const OUT_512: usize = 2;
-fn aiur_fn_512(
-  inp: [G; IN_512],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_512], 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_503] = { let __args: [G; IN_503] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[503].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_503] = unsafe { *(result.output.as_ptr() as *const [G; OUT_503]) }; __ret } else { aiur_fn_503(__args, record, io_buffer, __cu)? } };
-    let __v_6: G = __r_arr[0];
-    let __v_7: G = __r_arr[1];
-    match __v_6.as_canonical_u64() {
-      1u64 => {
-        let __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[503].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_503] = unsafe { *(result.output.as_ptr() as *const [G; OUT_503]) }; __ret } else { aiur_fn_503(__args, record, io_buffer, __cu)? } };
-        let __v_8: G = __r_arr[0];
-        let __v_9: G = __r_arr[1];
-        match __v_8.as_canonical_u64() {
-          1u64 => {
-            let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_7, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } };
-            let __v_10: G = __r_arr[0];
-            let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_9, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } else { aiur_fn_439(__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_2 - __v_12);
-            let __r_arr: [G; OUT_505] = { let __args: [G; IN_505] = [__v_10, __v_11, __v_13, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[505].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_505] = unsafe { *(result.output.as_ptr() as *const [G; OUT_505]) }; __ret } else { aiur_fn_505(__args, record, io_buffer, __cu)? } };
-            let __v_14: G = __r_arr[0];
-            let __v_15: G = __r_arr[1];
-            let __ret: [G; OUT_512] = [__v_14, __v_15];
-            record.function_queries[512].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
+        let __v_4: G = (__v_0 - __v_1);
+        match __v_4.as_canonical_u64() {
           0u64 => {
-            let __v_10: G = G::from_u64(0);
-            let __v_11: G = G::from_u64(0);
-            let __ret: [G; OUT_512] = [__v_10, __v_11];
-            record.function_queries[512].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __v_5: G = G::from_u64(1);
+            let __ret: [G; OUT_419] = [__v_5];
+            record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64()));
+            let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[432].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_432] = unsafe { *(result.output.as_ptr() as *const [G; OUT_432]) }; __ret } else { aiur_fn_432(__args, record, io_buffer, __cu)? } };
+            let __v_5: G = __r_arr[0];
+            let __v_6: G = __r_arr[1];
+            let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[432].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_432] = unsafe { *(result.output.as_ptr() as *const [G; OUT_432]) }; __ret } else { aiur_fn_432(__args, record, io_buffer, __cu)? } };
+            let __v_7: G = __r_arr[0];
+            let __v_8: G = __r_arr[1];
+            match __v_6.as_canonical_u64() {
+              1u64 => {
+                match __v_8.as_canonical_u64() {
+                  1u64 => {
+                    let __r_arr: [G; OUT_397] = { let __args: [G; IN_397] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[397].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_397] = unsafe { *(result.output.as_ptr() as *const [G; OUT_397]) }; __ret } else { aiur_fn_397(__args, record, io_buffer, __cu)? } };
+                    let __v_9: G = __r_arr[0];
+                    match __v_9.as_canonical_u64() {
+                      1u64 => {
+                        let __v_10: G = G::from_u64(1);
+                        let __ret: [G; OUT_419] = [__v_10];
+                        record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        return Ok(__ret);
+                      },
+                      _ => {
+                        let __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_5, __v_7, __v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[421].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_421] = unsafe { *(result.output.as_ptr() as *const [G; OUT_421]) }; __ret } else { aiur_fn_421(__args, record, io_buffer, __cu)? } };
+                        let __v_10: G = __r_arr[0];
+                        let __ret: [G; OUT_419] = [__v_10];
+                        record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        return Ok(__ret);
+                      },
+                    }
+                  },
+                  _ => {
+                    let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_5, __v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[425].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_425] = unsafe { *(result.output.as_ptr() as *const [G; OUT_425]) }; __ret } else { aiur_fn_425(__args, record, io_buffer, __cu)? } };
+                    let __v_9: G = __r_arr[0];
+                    let __ret: [G; OUT_419] = [__v_9];
+                    record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
+                  },
+                }
+              },
+              _ => {
+                match __v_8.as_canonical_u64() {
+                  1u64 => {
+                    let __r_arr: [G; OUT_426] = { let __args: [G; IN_426] = [__v_7, __v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[426].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_426] = unsafe { *(result.output.as_ptr() as *const [G; OUT_426]) }; __ret } else { aiur_fn_426(__args, record, io_buffer, __cu)? } };
+                    let __v_9: G = __r_arr[0];
+                    let __ret: [G; OUT_419] = [__v_9];
+                    record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
+                  },
+                  _ => {
+                    let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[427].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_427] = unsafe { *(result.output.as_ptr() as *const [G; OUT_427]) }; __ret } else { aiur_fn_427(__args, record, io_buffer, __cu)? } };
+                    let __v_9: G = __r_arr[0];
+                    let __ret: [G; OUT_419] = [__v_9];
+                    record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
+                  },
+                }
+              },
+            }
           },
         }
       },
-      0u64 => {
-        let __v_8: G = G::from_u64(0);
-        let __v_9: G = G::from_u64(0);
-        let __ret: [G; OUT_512] = [__v_8, __v_9];
-        record.function_queries[512].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64()));
-      },
     }
   })
 }
 
-const INPUT_SIZE_513: usize = 7;
-const IN_513: usize = 7;
-const OUT_513: usize = 0;
-fn aiur_fn_513(
-  inp: [G; IN_513],
+const INPUT_SIZE_420: usize = 12;
+const IN_420: usize = 12;
+const OUT_420: usize = 1;
+fn aiur_fn_420(
+  inp: [G; IN_420],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_513], ExecError> {
+) -> Result<[G; OUT_420], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -45723,112 +36890,36 @@ fn aiur_fn_513(
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
     let __v_6: G = inp[6];
-    let __v_7: G = (__v_1 + __v_3);
-    let __r_arr: [G; OUT_516] = { let __args: [G; IN_516] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[516].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_516] = unsafe { *(result.output.as_ptr() as *const [G; OUT_516]) }; __ret } else { aiur_fn_516(__args, record, io_buffer, __cu)? } };
-    let __v_8: G = __r_arr[0];
-    let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[189].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_189] = unsafe { *(result.output.as_ptr() as *const [G; OUT_189]) }; __ret } else { aiur_fn_189(__args, record, io_buffer, __cu)? } };
-    let __v_9: G = __r_arr[0];
-    let __v_10: G = __r_arr[1];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; 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: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].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];
-    match __v_11.as_canonical_u64() {
-      2u64 => {
-        let __v_15: G = G::from_u64(0);
-        let __r_arr: [G; OUT_517] = { let __args: [G; IN_517] = [__v_13, __v_5, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[517].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_517] = unsafe { *(result.output.as_ptr() as *const [G; OUT_517]) }; __ret } else { aiur_fn_517(__args, record, io_buffer, __cu)? } };
-        let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { 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_16: G = __r_arr[0];
-        let __v_17: G = G::from_u64(0);
-        let __r_arr: [G; OUT_518] = { let __args: [G; IN_518] = [__v_10, __v_1, __v_3, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[518].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_518] = unsafe { *(result.output.as_ptr() as *const [G; OUT_518]) }; __ret } else { aiur_fn_518(__args, record, io_buffer, __cu)? } };
-        let __r_arr: [G; OUT_796] = { let __args: [G; IN_796] = [__v_10, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[796].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_796] = unsafe { *(result.output.as_ptr() as *const [G; OUT_796]) }; __ret } else { aiur_fn_796(__args, record, io_buffer, __cu)? } };
-        let __v_18: G = __r_arr[0];
-        let __r_arr: [G; OUT_559] = { let __args: [G; IN_559] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[559].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_559] = unsafe { *(result.output.as_ptr() as *const [G; OUT_559]) }; __ret } else { aiur_fn_559(__args, record, io_buffer, __cu)? } };
-        let __v_19: G = __r_arr[0];
-        if (__v_12 != __v_4) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_12.as_canonical_u64(), rhs: __v_4.as_canonical_u64() });
-        }
-        let __v_20: G = (__v_1 + __v_2);
-        if (__v_16 != __v_20) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_20.as_canonical_u64() });
-        }
-        let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } else { aiur_fn_533(__args, record, io_buffer, __cu)? } };
-        let __v_21: G = __r_arr[0];
-        let __v_22: G = G::from_u64(0);
-        if (__v_21 != __v_22) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_21.as_canonical_u64(), rhs: __v_22.as_canonical_u64() });
-        }
-        let __ret: [G; OUT_513] = [];
-        record.function_queries[513].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_514: usize = 3;
-const IN_514: usize = 3;
-const OUT_514: usize = 0;
-fn aiur_fn_514(
-  inp: [G; IN_514],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_514], 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_778] = { let __args: [G; IN_778] = [__v_1, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-    let __v_3: G = __r_arr[0];
-    let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr };
-    let __v_4: G = __loaded[0];
-    let __v_5: G = __loaded[1];
-    let __v_6: G = __loaded[2];
-    let __v_7: G = __loaded[3];
-    let __v_8: G = __loaded[4];
-    let __v_9: G = __loaded[5];
-    let __v_10: G = __loaded[6];
-    let __v_11: G = __loaded[7];
-    let __v_12: G = __loaded[8];
-    let __v_13: G = __loaded[9];
-    let __v_14: G = __loaded[10];
-    match __v_4.as_canonical_u64() {
-      5u64 => {
-        let __v_15: G = (__v_7 + __v_8);
-        let __v_16: G = G::from_u64(1);
-        let __v_17: G = G::from_u64(1);
-        let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __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 __r_arr: [G; OUT_519] = { let __args: [G; IN_519] = [__v_6, __v_15, __v_18, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[519].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_519] = unsafe { *(result.output.as_ptr() as *const [G; OUT_519]) }; __ret } else { aiur_fn_519(__args, record, io_buffer, __cu)? } };
-        let __v_19: G = __r_arr[0];
-        let __v_20: G = G::from_u64(0);
-        let __r_arr: [G; OUT_515] = { let __args: [G; IN_515] = [__v_9, __v_0, __v_6, __v_5, __v_7, __v_8, __v_19, __v_20, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[515].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_515] = unsafe { *(result.output.as_ptr() as *const [G; OUT_515]) }; __ret } else { aiur_fn_515(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_514] = [];
-        record.function_queries[514].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    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];
+    match __v_0.as_canonical_u64() {
+      1u64 => {
+        let __ret: [G; OUT_420] = [__v_5];
+        record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __ret: [G; OUT_514] = [];
-        record.function_queries[514].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __v_12: G = G::from_u64(0);
+        let __ret: [G; OUT_420] = [__v_12];
+        record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_515: usize = 10;
-const IN_515: usize = 10;
-const OUT_515: usize = 0;
-fn aiur_fn_515(
-  inp: [G; IN_515],
+const INPUT_SIZE_421: usize = 6;
+const IN_421: usize = 6;
+const OUT_421: usize = 1;
+fn aiur_fn_421(
+  inp: [G; IN_421],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_515], ExecError> {
+) -> Result<[G; OUT_421], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -45836,118 +36927,101 @@ fn aiur_fn_515(
     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 __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_10: G = __loaded[0];
-    let __v_11: G = __loaded[1];
-    let __v_12: G = __loaded[2];
-    match __v_10.as_canonical_u64() {
-      1u64 => {
-        let __ret: [G; OUT_515] = [];
-        record.function_queries[515].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
+    let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[258].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_258] = unsafe { *(result.output.as_ptr() as *const [G; OUT_258]) }; __ret } else { aiur_fn_258(__args, record, io_buffer, __cu)? } };
+    let __v_6: G = __r_arr[0];
+    let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; 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: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].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];
+    let __v_17: G = __loaded[10];
+    let __v_18: G = __loaded[11];
+    let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[258].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_258] = unsafe { *(result.output.as_ptr() as *const [G; OUT_258]) }; __ret } else { aiur_fn_258(__args, record, io_buffer, __cu)? } };
+    let __v_19: G = __r_arr[0];
+    let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; 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: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+    let __v_20: G = __loaded[0];
+    let __v_21: G = __loaded[1];
+    let __v_22: G = __loaded[2];
+    let __v_23: G = __loaded[3];
+    let __v_24: G = __loaded[4];
+    let __v_25: G = __loaded[5];
+    let __v_26: G = __loaded[6];
+    let __v_27: G = __loaded[7];
+    let __v_28: G = __loaded[8];
+    let __v_29: G = __loaded[9];
+    let __v_30: G = __loaded[10];
+    let __v_31: G = __loaded[11];
+    let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__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[428].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_428] = unsafe { *(result.output.as_ptr() as *const [G; OUT_428]) }; __ret } else { aiur_fn_428(__args, record, io_buffer, __cu)? } };
+    let __v_32: G = __r_arr[0];
+    let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[428].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_428] = unsafe { *(result.output.as_ptr() as *const [G; OUT_428]) }; __ret } else { aiur_fn_428(__args, record, io_buffer, __cu)? } };
+    let __v_33: G = __r_arr[0];
+    match __v_32.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-        let __v_13: G = __r_arr[0];
-        let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].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];
-        let __v_18: G = __loaded[4];
-        let __v_19: G = __loaded[5];
-        let __v_20: G = __loaded[6];
-        let __v_21: G = __loaded[7];
-        let __v_22: G = __loaded[8];
-        let __v_23: G = __loaded[9];
-        let __v_24: G = __loaded[10];
-        match __v_14.as_canonical_u64() {
-          6u64 => {
-            let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_2, __v_16, __v_4, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = unsafe { *(result.output.as_ptr() as *const [G; OUT_652]) }; __ret } else { aiur_fn_652(__args, record, io_buffer, __cu)? } };
-            let __r_arr: [G; OUT_513] = { let __args: [G; IN_513] = [__v_16, __v_19, __v_5, __v_20, __v_1, __v_3, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[513].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_513] = unsafe { *(result.output.as_ptr() as *const [G; OUT_513]) }; __ret } else { aiur_fn_513(__args, record, io_buffer, __cu)? } };
-            let __v_25: G = G::from_u64(1);
-            let __v_26: G = G::from_u64(1);
-            let __v_27: G = { let __values: [G; 3] = [__v_25, __v_26, __v_26]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_520] = { let __args: [G; IN_520] = [__v_16, __v_19, __v_6, __v_27, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[520].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_520] = unsafe { *(result.output.as_ptr() as *const [G; OUT_520]) }; __ret } else { aiur_fn_520(__args, record, io_buffer, __cu)? } };
-            let __v_28: G = G::from_u64(1);
-            let __v_29: G = G::from_u64(1);
-            let __v_30: G = { let __values: [G; 3] = [__v_28, __v_29, __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 __r_arr: [G; OUT_523] = { let __args: [G; IN_523] = [__v_16, __v_19, __v_1, __v_30, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[523].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_523] = unsafe { *(result.output.as_ptr() as *const [G; OUT_523]) }; __ret } else { aiur_fn_523(__args, record, io_buffer, __cu)? } };
-            if (__v_17 != __v_1) {
-              return Err(ExecError::AssertEqMismatch { lhs: __v_17.as_canonical_u64(), rhs: __v_1.as_canonical_u64() });
-            }
-            if (__v_18 != __v_7) {
-              return Err(ExecError::AssertEqMismatch { lhs: __v_18.as_canonical_u64(), rhs: __v_7.as_canonical_u64() });
-            }
-            if (__v_19 != __v_4) {
-              return Err(ExecError::AssertEqMismatch { lhs: __v_19.as_canonical_u64(), rhs: __v_4.as_canonical_u64() });
-            }
-            let __v_31: G = G::from_u64(1);
-            let __v_32: G = (__v_7 + __v_31);
-            let __r_arr: [G; OUT_515] = { let __args: [G; IN_515] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_32, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[515].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_515] = unsafe { *(result.output.as_ptr() as *const [G; OUT_515]) }; __ret } else { aiur_fn_515(__args, record, io_buffer, __cu)? } };
-            let __ret: [G; OUT_515] = [];
-            record.function_queries[515].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        match __v_33.as_canonical_u64() {
+          0u64 => {
+            let __v_34: G = G::from_u64(0);
+            let __ret: [G; OUT_421] = [__v_34];
+            record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __v_25: G = G::from_u64(0);
-            let __v_26: G = G::from_u64(1);
-            if (__v_25 != __v_26) {
-              return Err(ExecError::AssertEqMismatch { lhs: __v_25.as_canonical_u64(), rhs: __v_26.as_canonical_u64() });
-            }
-            let __ret: [G; OUT_515] = [];
-            record.function_queries[515].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[423].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_423] = unsafe { *(result.output.as_ptr() as *const [G; OUT_423]) }; __ret } else { aiur_fn_423(__args, record, io_buffer, __cu)? } };
+            let __v_34: G = __r_arr[0];
+            let __ret: [G; OUT_421] = [__v_34];
+            record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_516: usize = 2;
-const IN_516: usize = 2;
-const OUT_516: usize = 1;
-fn aiur_fn_516(
-  inp: [G; IN_516],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_516], 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_516] = [__v_0];
-        record.function_queries[516].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        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() {
-          5u64 => {
-            let __v_6: G = G::from_u64(1);
-            let __v_7: G = (__v_1 - __v_6);
-            let __r_arr: [G; OUT_516] = { let __args: [G; IN_516] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[516].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_516] = unsafe { *(result.output.as_ptr() as *const [G; OUT_516]) }; __ret } else { aiur_fn_516(__args, record, io_buffer, __cu)? } };
-            let __v_8: G = __r_arr[0];
-            let __ret: [G; OUT_516] = [__v_8];
-            record.function_queries[516].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        match __v_33.as_canonical_u64() {
+          0u64 => {
+            let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[422].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_422] = unsafe { *(result.output.as_ptr() as *const [G; OUT_422]) }; __ret } else { aiur_fn_422(__args, record, io_buffer, __cu)? } };
+            let __v_34: G = __r_arr[0];
+            let __ret: [G; OUT_421] = [__v_34];
+            record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+            let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__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[420].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } else { aiur_fn_420(__args, record, io_buffer, __cu)? } };
+            let __v_34: G = __r_arr[0];
+            let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } else { aiur_fn_420(__args, record, io_buffer, __cu)? } };
+            let __v_35: G = __r_arr[0];
+            let __v_36: G = { let __a_val = __v_35.as_canonical_u64(); let __b_val = __v_34.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_36.as_canonical_u64() {
+              1u64 => {
+                let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[422].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_422] = unsafe { *(result.output.as_ptr() as *const [G; OUT_422]) }; __ret } else { aiur_fn_422(__args, record, io_buffer, __cu)? } };
+                let __v_37: G = __r_arr[0];
+                let __ret: [G; OUT_421] = [__v_37];
+                record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                let __v_37: G = { let __a_val = __v_34.as_canonical_u64(); let __b_val = __v_35.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_37.as_canonical_u64() {
+                  1u64 => {
+                    let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[423].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_423] = unsafe { *(result.output.as_ptr() as *const [G; OUT_423]) }; __ret } else { aiur_fn_423(__args, record, io_buffer, __cu)? } };
+                    let __v_38: G = __r_arr[0];
+                    let __ret: [G; OUT_421] = [__v_38];
+                    record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
+                  },
+                  _ => {
+                    let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[424].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_424] = unsafe { *(result.output.as_ptr() as *const [G; OUT_424]) }; __ret } else { aiur_fn_424(__args, record, io_buffer, __cu)? } };
+                    let __v_38: G = __r_arr[0];
+                    let __ret: [G; OUT_421] = [__v_38];
+                    record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
+                  },
+                }
+              },
+            }
           },
         }
       },
@@ -45955,273 +37029,345 @@ fn aiur_fn_516(
   })
 }
 
-const INPUT_SIZE_517: usize = 3;
-const IN_517: usize = 3;
-const OUT_517: usize = 0;
-fn aiur_fn_517(
-  inp: [G; IN_517],
+const INPUT_SIZE_422: usize = 4;
+const IN_422: usize = 4;
+const OUT_422: usize = 1;
+fn aiur_fn_422(
+  inp: [G; IN_422],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_517], ExecError> {
+) -> Result<[G; OUT_422], 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_1.as_canonical_u64() {
-      0u64 => {
-        let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { 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_3: G = __r_arr[0];
-        let __v_4: G = G::from_u64(0);
-        if (__v_3 != __v_4) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_4.as_canonical_u64() });
-        }
-        let __ret: [G; OUT_517] = [];
-        record.function_queries[517].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __v_3: G = inp[3];
+    let __r_arr: [G; OUT_430] = { let __args: [G; IN_430] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[430].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_430] = unsafe { *(result.output.as_ptr() as *const [G; OUT_430]) }; __ret } else { aiur_fn_430(__args, record, io_buffer, __cu)? } };
+    let __v_4: G = __r_arr[0];
+    let __v_5: G = __r_arr[1];
+    match __v_4.as_canonical_u64() {
+      1u64 => {
+        let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = unsafe { *(result.output.as_ptr() as *const [G; OUT_377]) }; __ret } else { aiur_fn_377(__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_2 - __v_7);
+        let __r_arr: [G; OUT_419] = { let __args: [G; IN_419] = [__v_6, __v_1, __v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[419].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_419] = unsafe { *(result.output.as_ptr() as *const [G; OUT_419]) }; __ret } else { aiur_fn_419(__args, record, io_buffer, __cu)? } };
+        let __v_9: G = __r_arr[0];
+        let __ret: [G; OUT_422] = [__v_9];
+        record.function_queries[422].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_3: G = __loaded[0];
-        let __v_4: G = __loaded[1];
-        let __v_5: G = __loaded[2];
-        match __v_3.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_6: G = __loaded[0];
-            let __v_7: G = __loaded[1];
-            let __v_8: G = __loaded[2];
-            match __v_6.as_canonical_u64() {
-              4u64 => {
-                let __v_9: G = G::from_u64(1);
-                let __v_10: G = (__v_1 - __v_9);
-                let __v_11: G = G::from_u64(1);
-                let __v_12: G = (__v_2 + __v_11);
-                let __r_arr: [G; OUT_517] = { let __args: [G; IN_517] = [__v_5, __v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[517].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_517] = unsafe { *(result.output.as_ptr() as *const [G; OUT_517]) }; __ret } else { aiur_fn_517(__args, record, io_buffer, __cu)? } };
-                if (__v_7 != __v_2) {
-                  return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_2.as_canonical_u64() });
-                }
-                let __ret: [G; OUT_517] = [];
-                record.function_queries[517].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()));
-          },
-        }
+        let __v_6: G = G::from_u64(0);
+        let __ret: [G; OUT_422] = [__v_6];
+        record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_518: usize = 4;
-const IN_518: usize = 4;
-const OUT_518: usize = 0;
-fn aiur_fn_518(
-  inp: [G; IN_518],
+const INPUT_SIZE_423: usize = 4;
+const IN_423: usize = 4;
+const OUT_423: usize = 1;
+fn aiur_fn_423(
+  inp: [G; IN_423],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_518], ExecError> {
+) -> Result<[G; OUT_423], 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_1 - __v_3);
+    let __r_arr: [G; OUT_430] = { let __args: [G; IN_430] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[430].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_430] = unsafe { *(result.output.as_ptr() as *const [G; OUT_430]) }; __ret } else { aiur_fn_430(__args, record, io_buffer, __cu)? } };
+    let __v_4: G = __r_arr[0];
+    let __v_5: G = __r_arr[1];
     match __v_4.as_canonical_u64() {
-      0u64 => {
-        let __ret: [G; OUT_518] = [];
-        record.function_queries[518].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+      1u64 => {
+        let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = unsafe { *(result.output.as_ptr() as *const [G; OUT_377]) }; __ret } else { aiur_fn_377(__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_2 - __v_7);
+        let __r_arr: [G; OUT_419] = { let __args: [G; IN_419] = [__v_0, __v_6, __v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[419].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_419] = unsafe { *(result.output.as_ptr() as *const [G; OUT_419]) }; __ret } else { aiur_fn_419(__args, record, io_buffer, __cu)? } };
+        let __v_9: G = __r_arr[0];
+        let __ret: [G; OUT_423] = [__v_9];
+        record.function_queries[423].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_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; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; 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: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].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];
-            match __v_8.as_canonical_u64() {
-              0u64 => {
-                let __v_12: G = G::from_u64(1);
-                let __v_13: G = (__v_3 + __v_12);
-                let __r_arr: [G; OUT_518] = { let __args: [G; IN_518] = [__v_7, __v_1, __v_2, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[518].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_518] = unsafe { *(result.output.as_ptr() as *const [G; OUT_518]) }; __ret } else { aiur_fn_518(__args, record, io_buffer, __cu)? } };
-                let __v_14: G = (__v_2 + __v_1);
-                let __v_15: G = G::from_u64(1);
-                let __v_16: G = (__v_14 - __v_15);
-                let __v_17: G = (__v_16 - __v_3);
-                if (__v_9 != __v_17) {
-                  return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_17.as_canonical_u64() });
-                }
-                let __ret: [G; OUT_518] = [];
-                record.function_queries[518].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              _ => {
-                return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64()));
-              },
-            }
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
-          },
-        }
+        let __v_6: G = G::from_u64(0);
+        let __ret: [G; OUT_423] = [__v_6];
+        record.function_queries[423].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_519: usize = 5;
-const IN_519: usize = 5;
-const OUT_519: usize = 1;
-fn aiur_fn_519(
-  inp: [G; IN_519],
+const INPUT_SIZE_424: usize = 4;
+const IN_424: usize = 4;
+const OUT_424: usize = 1;
+fn aiur_fn_424(
+  inp: [G; IN_424],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_519], ExecError> {
+) -> Result<[G; OUT_424], 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_439] = { let __args: [G; IN_439] = [__v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } };
-    let __v_5: G = __r_arr[0];
-    match __v_1.as_canonical_u64() {
-      0u64 => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; 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: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].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 __r_arr: [G; OUT_430] = { let __args: [G; IN_430] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[430].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_430] = unsafe { *(result.output.as_ptr() as *const [G; OUT_430]) }; __ret } else { aiur_fn_430(__args, record, io_buffer, __cu)? } };
+    let __v_4: G = __r_arr[0];
+    let __v_5: G = __r_arr[1];
+    match __v_4.as_canonical_u64() {
+      1u64 => {
+        let __r_arr: [G; OUT_430] = { let __args: [G; IN_430] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[430].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_430] = unsafe { *(result.output.as_ptr() as *const [G; OUT_430]) }; __ret } else { aiur_fn_430(__args, record, io_buffer, __cu)? } };
+        let __v_6: G = __r_arr[0];
+        let __v_7: G = __r_arr[1];
         match __v_6.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_519] = [__v_7];
-            record.function_queries[519].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = unsafe { *(result.output.as_ptr() as *const [G; OUT_377]) }; __ret } else { aiur_fn_377(__args, record, io_buffer, __cu)? } };
+            let __v_8: G = __r_arr[0];
+            let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_7, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = unsafe { *(result.output.as_ptr() as *const [G; OUT_377]) }; __ret } else { aiur_fn_377(__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_2 - __v_10);
+            let __r_arr: [G; OUT_419] = { let __args: [G; IN_419] = [__v_8, __v_9, __v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[419].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_419] = unsafe { *(result.output.as_ptr() as *const [G; OUT_419]) }; __ret } else { aiur_fn_419(__args, record, io_buffer, __cu)? } };
+            let __v_12: G = __r_arr[0];
+            let __ret: [G; OUT_424] = [__v_12];
+            record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64()));
+            let __v_8: G = G::from_u64(0);
+            let __ret: [G; OUT_424] = [__v_8];
+            record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
           },
         }
       },
       _ => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; 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: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].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];
-        match __v_6.as_canonical_u64() {
-          5u64 => {
-            let __v_10: G = G::from_u64(1);
-            let __v_11: G = (__v_1 - __v_10);
-            let __v_12: G = G::from_u64(0);
-            let __v_13: G = { let __values: [G; 3] = [__v_12, __v_7, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_519] = { let __args: [G; IN_519] = [__v_8, __v_11, __v_13, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[519].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_519] = unsafe { *(result.output.as_ptr() as *const [G; OUT_519]) }; __ret } else { aiur_fn_519(__args, record, io_buffer, __cu)? } };
-            let __v_14: G = __r_arr[0];
-            let __ret: [G; OUT_519] = [__v_14];
-            record.function_queries[519].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64()));
-          },
-        }
+        let __v_6: G = G::from_u64(0);
+        let __ret: [G; OUT_424] = [__v_6];
+        record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_520: usize = 6;
-const IN_520: usize = 6;
-const OUT_520: usize = 0;
-fn aiur_fn_520(
-  inp: [G; IN_520],
+const INPUT_SIZE_425: usize = 5;
+const IN_425: usize = 5;
+const OUT_425: usize = 1;
+fn aiur_fn_425(
+  inp: [G; IN_425],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_520], ExecError> {
+) -> Result<[G; OUT_425], 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_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 __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[258].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_258] = unsafe { *(result.output.as_ptr() as *const [G; OUT_258]) }; __ret } else { aiur_fn_258(__args, record, io_buffer, __cu)? } };
+    let __v_5: G = __r_arr[0];
+    let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; 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: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].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() {
+    let __v_9: G = __loaded[3];
+    let __v_10: G = __loaded[4];
+    let __v_11: G = __loaded[5];
+    let __v_12: G = __loaded[6];
+    let __v_13: G = __loaded[7];
+    let __v_14: G = __loaded[8];
+    let __v_15: G = __loaded[9];
+    let __v_16: G = __loaded[10];
+    let __v_17: G = __loaded[11];
+    let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[428].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_428] = unsafe { *(result.output.as_ptr() as *const [G; OUT_428]) }; __ret } else { aiur_fn_428(__args, record, io_buffer, __cu)? } };
+    let __v_18: G = __r_arr[0];
+    match __v_18.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_520] = [];
-        record.function_queries[520].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __v_19: G = G::from_u64(0);
+        let __ret: [G; OUT_425] = [__v_19];
+        record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_521] = { let __args: [G; IN_521] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[521].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_521] = unsafe { *(result.output.as_ptr() as *const [G; OUT_521]) }; __ret } else { aiur_fn_521(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_520] = [];
-        record.function_queries[520].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
+        let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } else { aiur_fn_429(__args, record, io_buffer, __cu)? } };
+        let __v_19: G = __r_arr[0];
+        let __v_20: G = __r_arr[1];
+        match __v_19.as_canonical_u64() {
+          1u64 => {
+            let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_20, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = unsafe { *(result.output.as_ptr() as *const [G; OUT_377]) }; __ret } else { aiur_fn_377(__args, record, io_buffer, __cu)? } };
+            let __v_21: G = __r_arr[0];
+            let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_1, __v_21, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } };
+            let __v_22: G = __r_arr[0];
+            match __v_22.as_canonical_u64() {
+              1u64 => {
+                let __v_23: G = G::from_u64(1);
+                let __ret: [G; OUT_425] = [__v_23];
+                record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                let __v_23: G = G::from_u64(1);
+                let __v_24: G = (__v_3 - __v_23);
+                let __r_arr: [G; OUT_419] = { let __args: [G; IN_419] = [__v_1, __v_21, __v_24, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[419].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_419] = unsafe { *(result.output.as_ptr() as *const [G; OUT_419]) }; __ret } else { aiur_fn_419(__args, record, io_buffer, __cu)? } };
+                let __v_25: G = __r_arr[0];
+                let __ret: [G; OUT_425] = [__v_25];
+                record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+            }
+          },
+          _ => {
+            let __r_arr: [G; OUT_433] = { let __args: [G; IN_433] = [__v_1, __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_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[433].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_433] = unsafe { *(result.output.as_ptr() as *const [G; OUT_433]) }; __ret } else { aiur_fn_433(__args, record, io_buffer, __cu)? } };
+            let __v_21: G = __r_arr[0];
+            let __v_22: G = __r_arr[1];
+            match __v_21.as_canonical_u64() {
+              1u64 => {
+                let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_22, __v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } };
+                let __v_23: G = __r_arr[0];
+                match __v_23.as_canonical_u64() {
+                  1u64 => {
+                    let __v_24: G = G::from_u64(1);
+                    let __ret: [G; OUT_425] = [__v_24];
+                    record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
+                  },
+                  _ => {
+                    let __v_24: G = G::from_u64(1);
+                    let __v_25: G = (__v_3 - __v_24);
+                    let __r_arr: [G; OUT_419] = { let __args: [G; IN_419] = [__v_22, __v_2, __v_25, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[419].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_419] = unsafe { *(result.output.as_ptr() as *const [G; OUT_419]) }; __ret } else { aiur_fn_419(__args, record, io_buffer, __cu)? } };
+                    let __v_26: G = __r_arr[0];
+                    let __ret: [G; OUT_425] = [__v_26];
+                    record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
+                  },
+                }
+              },
+              _ => {
+                let __v_23: G = G::from_u64(0);
+                let __ret: [G; OUT_425] = [__v_23];
+                record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+            }
+          },
+        }
       },
     }
   })
 }
 
-const INPUT_SIZE_521: usize = 6;
-const IN_521: usize = 6;
-const OUT_521: usize = 0;
-fn aiur_fn_521(
-  inp: [G; IN_521],
+const INPUT_SIZE_426: usize = 5;
+const IN_426: usize = 5;
+const OUT_426: usize = 1;
+fn aiur_fn_426(
+  inp: [G; IN_426],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_521], ExecError> {
+) -> Result<[G; OUT_426], 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];
-    match __v_1.as_canonical_u64() {
+    let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[258].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_258] = unsafe { *(result.output.as_ptr() as *const [G; OUT_258]) }; __ret } else { aiur_fn_258(__args, record, io_buffer, __cu)? } };
+    let __v_5: G = __r_arr[0];
+    let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; 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: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].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];
+    let __v_13: G = __loaded[7];
+    let __v_14: G = __loaded[8];
+    let __v_15: G = __loaded[9];
+    let __v_16: G = __loaded[10];
+    let __v_17: G = __loaded[11];
+    let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[428].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_428] = unsafe { *(result.output.as_ptr() as *const [G; OUT_428]) }; __ret } else { aiur_fn_428(__args, record, io_buffer, __cu)? } };
+    let __v_18: G = __r_arr[0];
+    match __v_18.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_522] = { let __args: [G; IN_522] = [__v_0, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[522].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_522] = unsafe { *(result.output.as_ptr() as *const [G; OUT_522]) }; __ret } else { aiur_fn_522(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_521] = [];
-        record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __v_19: G = G::from_u64(0);
+        let __ret: [G; OUT_426] = [__v_19];
+        record.function_queries[426].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        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_6: G = __loaded[0];
-        let __v_7: G = __loaded[1];
-        let __v_8: G = __loaded[2];
-        let __v_9: G = __loaded[3];
-        match __v_6.as_canonical_u64() {
-          5u64 => {
-            let __v_10: G = G::from_u64(0);
-            let __v_11: G = { let __values: [G; 3] = [__v_10, __v_7, __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 __v_12: G = G::from_u64(1);
-            let __v_13: G = (__v_1 - __v_12);
-            let __r_arr: [G; OUT_521] = { let __args: [G; IN_521] = [__v_8, __v_13, __v_2, __v_11, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[521].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_521] = unsafe { *(result.output.as_ptr() as *const [G; OUT_521]) }; __ret } else { aiur_fn_521(__args, record, io_buffer, __cu)? } };
-            let __ret: [G; OUT_521] = [];
-            record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
+        let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } else { aiur_fn_429(__args, record, io_buffer, __cu)? } };
+        let __v_19: G = __r_arr[0];
+        let __v_20: G = __r_arr[1];
+        match __v_19.as_canonical_u64() {
+          1u64 => {
+            let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_20, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = unsafe { *(result.output.as_ptr() as *const [G; OUT_377]) }; __ret } else { aiur_fn_377(__args, record, io_buffer, __cu)? } };
+            let __v_21: G = __r_arr[0];
+            let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_21, __v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } };
+            let __v_22: G = __r_arr[0];
+            match __v_22.as_canonical_u64() {
+              1u64 => {
+                let __v_23: G = G::from_u64(1);
+                let __ret: [G; OUT_426] = [__v_23];
+                record.function_queries[426].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                let __v_23: G = G::from_u64(1);
+                let __v_24: G = (__v_3 - __v_23);
+                let __r_arr: [G; OUT_419] = { let __args: [G; IN_419] = [__v_21, __v_2, __v_24, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[419].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_419] = unsafe { *(result.output.as_ptr() as *const [G; OUT_419]) }; __ret } else { aiur_fn_419(__args, record, io_buffer, __cu)? } };
+                let __v_25: G = __r_arr[0];
+                let __ret: [G; OUT_426] = [__v_25];
+                record.function_queries[426].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+            }
           },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64()));
+            let __r_arr: [G; OUT_433] = { let __args: [G; IN_433] = [__v_2, __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_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[433].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_433] = unsafe { *(result.output.as_ptr() as *const [G; OUT_433]) }; __ret } else { aiur_fn_433(__args, record, io_buffer, __cu)? } };
+            let __v_21: G = __r_arr[0];
+            let __v_22: G = __r_arr[1];
+            match __v_21.as_canonical_u64() {
+              1u64 => {
+                let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_1, __v_22, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } };
+                let __v_23: G = __r_arr[0];
+                match __v_23.as_canonical_u64() {
+                  1u64 => {
+                    let __v_24: G = G::from_u64(1);
+                    let __ret: [G; OUT_426] = [__v_24];
+                    record.function_queries[426].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
+                  },
+                  _ => {
+                    let __v_24: G = G::from_u64(1);
+                    let __v_25: G = (__v_3 - __v_24);
+                    let __r_arr: [G; OUT_419] = { let __args: [G; IN_419] = [__v_1, __v_22, __v_25, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[419].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_419] = unsafe { *(result.output.as_ptr() as *const [G; OUT_419]) }; __ret } else { aiur_fn_419(__args, record, io_buffer, __cu)? } };
+                    let __v_26: G = __r_arr[0];
+                    let __ret: [G; OUT_426] = [__v_26];
+                    record.function_queries[426].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
+                  },
+                }
+              },
+              _ => {
+                let __v_23: G = G::from_u64(0);
+                let __ret: [G; OUT_426] = [__v_23];
+                record.function_queries[426].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+            }
           },
         }
       },
@@ -46229,61 +37375,123 @@ fn aiur_fn_521(
   })
 }
 
-const INPUT_SIZE_522: usize = 5;
-const IN_522: usize = 5;
-const OUT_522: usize = 0;
-fn aiur_fn_522(
-  inp: [G; IN_522],
+const INPUT_SIZE_427: usize = 4;
+const IN_427: usize = 4;
+const OUT_427: usize = 1;
+fn aiur_fn_427(
+  inp: [G; IN_427],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_522], ExecError> {
+) -> Result<[G; OUT_427], 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 __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_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() {
-      5u64 => {
-        let __r_arr: [G; OUT_465] = { let __args: [G; IN_465] = [__v_6, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[465].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_465] = unsafe { *(result.output.as_ptr() as *const [G; OUT_465]) }; __ret } else { aiur_fn_465(__args, record, io_buffer, __cu)? } };
-        let __v_9: G = __r_arr[0];
-        let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_9, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[215].get_mut(&__args[..]) { 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_10: G = __r_arr[0];
-        let __v_11: G = G::from_u64(0);
-        let __v_12: G = { let __values: [G; 3] = [__v_11, __v_6, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_13: G = G::from_u64(1);
-        if (__v_10 != __v_13) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_10.as_canonical_u64(), rhs: __v_13.as_canonical_u64() });
+    let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } else { aiur_fn_429(__args, record, io_buffer, __cu)? } };
+    let __v_4: G = __r_arr[0];
+    let __v_5: G = __r_arr[1];
+    let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } else { aiur_fn_429(__args, record, io_buffer, __cu)? } };
+    let __v_6: G = __r_arr[0];
+    let __v_7: G = __r_arr[1];
+    match __v_4.as_canonical_u64() {
+      1u64 => {
+        let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = unsafe { *(result.output.as_ptr() as *const [G; OUT_377]) }; __ret } else { aiur_fn_377(__args, record, io_buffer, __cu)? } };
+        let __v_8: G = __r_arr[0];
+        match __v_6.as_canonical_u64() {
+          1u64 => {
+            let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_7, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = unsafe { *(result.output.as_ptr() as *const [G; OUT_377]) }; __ret } else { aiur_fn_377(__args, record, io_buffer, __cu)? } };
+            let __v_9: G = __r_arr[0];
+            let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_8, __v_9, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } };
+            let __v_10: G = __r_arr[0];
+            match __v_10.as_canonical_u64() {
+              1u64 => {
+                let __v_11: G = G::from_u64(1);
+                let __ret: [G; OUT_427] = [__v_11];
+                record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                let __v_11: G = G::from_u64(1);
+                let __v_12: G = (__v_2 - __v_11);
+                let __r_arr: [G; OUT_419] = { let __args: [G; IN_419] = [__v_8, __v_9, __v_12, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[419].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_419] = unsafe { *(result.output.as_ptr() as *const [G; OUT_419]) }; __ret } else { aiur_fn_419(__args, record, io_buffer, __cu)? } };
+                let __v_13: G = __r_arr[0];
+                let __ret: [G; OUT_427] = [__v_13];
+                record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+            }
+          },
+          _ => {
+            let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_8, __v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } };
+            let __v_9: G = __r_arr[0];
+            match __v_9.as_canonical_u64() {
+              1u64 => {
+                let __v_10: G = G::from_u64(1);
+                let __ret: [G; OUT_427] = [__v_10];
+                record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                let __v_10: G = G::from_u64(1);
+                let __v_11: G = (__v_2 - __v_10);
+                let __r_arr: [G; OUT_419] = { let __args: [G; IN_419] = [__v_8, __v_1, __v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[419].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_419] = unsafe { *(result.output.as_ptr() as *const [G; OUT_419]) }; __ret } else { aiur_fn_419(__args, record, io_buffer, __cu)? } };
+                let __v_12: G = __r_arr[0];
+                let __ret: [G; OUT_427] = [__v_12];
+                record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+            }
+          },
         }
-        let __r_arr: [G; OUT_522] = { let __args: [G; IN_522] = [__v_7, __v_1, __v_12, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[522].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_522] = unsafe { *(result.output.as_ptr() as *const [G; OUT_522]) }; __ret } else { aiur_fn_522(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_522] = [];
-        record.function_queries[522].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
       },
       _ => {
-        let __ret: [G; OUT_522] = [];
-        record.function_queries[522].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
+        match __v_6.as_canonical_u64() {
+          1u64 => {
+            let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_7, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = unsafe { *(result.output.as_ptr() as *const [G; OUT_377]) }; __ret } else { aiur_fn_377(__args, record, io_buffer, __cu)? } };
+            let __v_8: G = __r_arr[0];
+            let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_0, __v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } };
+            let __v_9: G = __r_arr[0];
+            match __v_9.as_canonical_u64() {
+              1u64 => {
+                let __v_10: G = G::from_u64(1);
+                let __ret: [G; OUT_427] = [__v_10];
+                record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                let __v_10: G = G::from_u64(1);
+                let __v_11: G = (__v_2 - __v_10);
+                let __r_arr: [G; OUT_419] = { let __args: [G; IN_419] = [__v_0, __v_8, __v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[419].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_419] = unsafe { *(result.output.as_ptr() as *const [G; OUT_419]) }; __ret } else { aiur_fn_419(__args, record, io_buffer, __cu)? } };
+                let __v_12: G = __r_arr[0];
+                let __ret: [G; OUT_427] = [__v_12];
+                record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+            }
+          },
+          _ => {
+            let __v_8: G = G::from_u64(0);
+            let __ret: [G; OUT_427] = [__v_8];
+            record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+        }
       },
     }
   })
 }
 
-const INPUT_SIZE_523: usize = 6;
-const IN_523: usize = 6;
-const OUT_523: usize = 0;
-fn aiur_fn_523(
-  inp: [G; IN_523],
+const INPUT_SIZE_428: usize = 12;
+const IN_428: usize = 12;
+const OUT_428: usize = 1;
+fn aiur_fn_428(
+  inp: [G; IN_428],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_523], ExecError> {
+) -> Result<[G; OUT_428], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -46291,274 +37499,272 @@ fn aiur_fn_523(
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
-    let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } else { aiur_fn_525(__args, record, io_buffer, __cu)? } };
-    let __v_6: G = __r_arr[0];
-    let __v_7: G = __r_arr[1];
-    let __r_arr: [G; OUT_559] = { let __args: [G; IN_559] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[559].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_559] = unsafe { *(result.output.as_ptr() as *const [G; OUT_559]) }; __ret } else { aiur_fn_559(__args, record, io_buffer, __cu)? } };
-    let __v_8: G = __r_arr[0];
-    let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = [__v_6, __v_8, __v_7, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[526].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_526] = unsafe { *(result.output.as_ptr() as *const [G; OUT_526]) }; __ret } else { aiur_fn_526(__args, record, io_buffer, __cu)? } };
-    let __ret: [G; OUT_523] = [];
-    record.function_queries[523].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
+    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];
+    match __v_0.as_canonical_u64() {
+      1u64 => {
+        let __v_12: G = G::from_u64(1);
+        let __ret: [G; OUT_428] = [__v_12];
+        record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      2u64 => {
+        let __v_12: G = G::from_u64(1);
+        let __ret: [G; OUT_428] = [__v_12];
+        record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __v_12: G = G::from_u64(0);
+        let __ret: [G; OUT_428] = [__v_12];
+        record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+    }
   })
 }
 
-const INPUT_SIZE_524: usize = 2;
-const IN_524: usize = 2;
-const OUT_524: usize = 1;
-fn aiur_fn_524(
-  inp: [G; IN_524],
+const INPUT_SIZE_429: usize = 1;
+const IN_429: usize = 1;
+const OUT_429: usize = 2;
+fn aiur_fn_429(
+  inp: [G; IN_429],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_524], ExecError> {
+) -> Result<[G; OUT_429], 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_524] = [__v_0];
-        record.function_queries[524].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        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() {
-          5u64 => {
-            let __v_6: G = G::from_u64(1);
-            let __v_7: G = (__v_1 - __v_6);
-            let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } else { aiur_fn_524(__args, record, io_buffer, __cu)? } };
-            let __v_8: G = __r_arr[0];
-            let __ret: [G; OUT_524] = [__v_8];
-            record.function_queries[524].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[106].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_106] = unsafe { *(result.output.as_ptr() as *const [G; OUT_106]) }; __ret } else { aiur_fn_106(__args, record, io_buffer, __cu)? } };
+    let __v_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    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_3: G = __loaded[0];
+    let __v_4: G = __loaded[1];
+    let __v_5: G = __loaded[2];
+    let __v_6: G = __loaded[3];
+    match __v_3.as_canonical_u64() {
+      8u64 => {
+        let __r_arr: [G; OUT_430] = { let __args: [G; IN_430] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[430].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_430] = unsafe { *(result.output.as_ptr() as *const [G; OUT_430]) }; __ret } else { aiur_fn_430(__args, record, io_buffer, __cu)? } };
+        let __v_7: G = __r_arr[0];
+        let __v_8: G = __r_arr[1];
+        match __v_7.as_canonical_u64() {
+          1u64 => {
+            let __v_9: G = G::from_u64(8);
+            let __v_10: G = { let __values: [G; 4] = [__v_9, __v_4, __v_5, __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 __v_11: G = G::from_u64(1);
+            let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_10, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } };
+            let __v_12: G = __r_arr[0];
+            let __ret: [G; OUT_429] = [__v_11, __v_12];
+            record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __ret: [G; OUT_524] = [__v_0];
-            record.function_queries[524].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __v_9: G = G::from_u64(0);
+            let __ret: [G; OUT_429] = [__v_9, __v_0];
+            record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
+      _ => {
+        let __v_7: G = G::from_u64(0);
+        let __ret: [G; OUT_429] = [__v_7, __v_0];
+        record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
     }
   })
 }
 
-const INPUT_SIZE_525: usize = 3;
-const IN_525: usize = 3;
-const OUT_525: usize = 2;
-fn aiur_fn_525(
-  inp: [G; IN_525],
+const INPUT_SIZE_430: usize = 1;
+const IN_430: usize = 1;
+const OUT_430: usize = 2;
+fn aiur_fn_430(
+  inp: [G; IN_430],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_525], ExecError> {
+) -> Result<[G; OUT_430], 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_1.as_canonical_u64() {
-      0u64 => {
-        let __ret: [G; OUT_525] = [__v_0, __v_2];
-        record.function_queries[525].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        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_3: G = __loaded[0];
-        let __v_4: G = __loaded[1];
-        let __v_5: G = __loaded[2];
-        let __v_6: G = __loaded[3];
-        match __v_3.as_canonical_u64() {
-          5u64 => {
-            let __v_7: G = G::from_u64(0);
-            let __v_8: G = { let __values: [G; 3] = [__v_7, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __v_9: G = G::from_u64(1);
-            let __v_10: G = (__v_1 - __v_9);
-            let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_5, __v_10, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } else { aiur_fn_525(__args, record, io_buffer, __cu)? } };
-            let __v_11: G = __r_arr[0];
-            let __v_12: G = __r_arr[1];
-            let __ret: [G; OUT_525] = [__v_11, __v_12];
-            record.function_queries[525].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[106].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_106] = unsafe { *(result.output.as_ptr() as *const [G; OUT_106]) }; __ret } else { aiur_fn_106(__args, record, io_buffer, __cu)? } };
+    let __v_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    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_3: G = __loaded[0];
+    let __v_4: G = __loaded[1];
+    let __v_5: G = __loaded[2];
+    let __v_6: G = __loaded[3];
+    match __v_3.as_canonical_u64() {
+      2u64 => {
+        let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[258].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_258] = unsafe { *(result.output.as_ptr() as *const [G; OUT_258]) }; __ret } else { aiur_fn_258(__args, record, io_buffer, __cu)? } };
+        let __v_7: G = __r_arr[0];
+        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; 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: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].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];
+        let __v_18: G = __loaded[10];
+        let __v_19: G = __loaded[11];
+        match __v_8.as_canonical_u64() {
+          1u64 => {
+            let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_11, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } else { aiur_fn_307(__args, record, io_buffer, __cu)? } };
+            let __v_20: G = __r_arr[0];
+            let __v_21: G = G::from_u64(1);
+            let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_20, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } };
+            let __v_22: G = __r_arr[0];
+            let __ret: [G; OUT_430] = [__v_21, __v_22];
+            record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          2u64 => {
+            let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_11, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } else { aiur_fn_307(__args, record, io_buffer, __cu)? } };
+            let __v_20: G = __r_arr[0];
+            let __v_21: G = G::from_u64(1);
+            let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_20, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } };
+            let __v_22: G = __r_arr[0];
+            let __ret: [G; OUT_430] = [__v_21, __v_22];
+            record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __ret: [G; OUT_525] = [__v_0, __v_2];
-            record.function_queries[525].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __v_20: G = G::from_u64(0);
+            let __ret: [G; OUT_430] = [__v_20, __v_0];
+            record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
-    }
-  })
-}
-
-const INPUT_SIZE_526: usize = 5;
-const IN_526: usize = 5;
-const OUT_526: usize = 0;
-fn aiur_fn_526(
-  inp: [G; IN_526],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_526], 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 __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_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() {
-      5u64 => {
-        let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_6, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } else { aiur_fn_527(__args, record, io_buffer, __cu)? } };
-        let __v_9: G = G::from_u64(0);
-        let __v_10: G = { let __values: [G; 3] = [__v_9, __v_6, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_526] = { let __args: [G; IN_526] = [__v_7, __v_1, __v_10, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[526].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_526] = unsafe { *(result.output.as_ptr() as *const [G; OUT_526]) }; __ret } else { aiur_fn_526(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_526] = [];
-        record.function_queries[526].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
       _ => {
-        let __ret: [G; OUT_526] = [];
-        record.function_queries[526].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __v_7: G = G::from_u64(0);
+        let __ret: [G; OUT_430] = [__v_7, __v_0];
+        record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_527: usize = 5;
-const IN_527: usize = 5;
-const OUT_527: usize = 0;
-fn aiur_fn_527(
-  inp: [G; IN_527],
+const INPUT_SIZE_431: usize = 3;
+const IN_431: usize = 3;
+const OUT_431: usize = 1;
+fn aiur_fn_431(
+  inp: [G; IN_431],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_527], ExecError> {
+) -> Result<[G; OUT_431], 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_532] = { let __args: [G; IN_532] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } else { aiur_fn_532(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[432].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_432] = unsafe { *(result.output.as_ptr() as *const [G; OUT_432]) }; __ret } else { aiur_fn_432(__args, record, io_buffer, __cu)? } };
+    let __v_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[432].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_432] = unsafe { *(result.output.as_ptr() as *const [G; OUT_432]) }; __ret } else { aiur_fn_432(__args, record, io_buffer, __cu)? } };
     let __v_5: G = __r_arr[0];
-    match __v_5.as_canonical_u64() {
+    let __v_6: G = __r_arr[1];
+    match __v_4.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_527] = [];
-        record.function_queries[527].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __v_7: G = G::from_u64(0);
+        let __ret: [G; OUT_431] = [__v_7];
+        record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } };
-        let __v_6: 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_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: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].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];
-        match __v_7.as_canonical_u64() {
-          5u64 => {
-            let __v_11: G = G::from_u64(0);
-            let __v_12: G = { let __values: [G; 3] = [__v_11, __v_8, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_532] = { let __args: [G; IN_532] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } else { aiur_fn_532(__args, record, io_buffer, __cu)? } };
-            let __v_13: G = __r_arr[0];
-            let __v_14: G = G::from_u64(0);
-            if (__v_13 != __v_14) {
-              return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_14.as_canonical_u64() });
-            }
-            let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_9, __v_1, __v_12, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } else { aiur_fn_527(__args, record, io_buffer, __cu)? } };
-            let __ret: [G; OUT_527] = [];
-            record.function_queries[527].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        match __v_6.as_canonical_u64() {
+          0u64 => {
+            let __v_7: G = G::from_u64(0);
+            let __ret: [G; OUT_431] = [__v_7];
+            record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[189].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_189] = unsafe { *(result.output.as_ptr() as *const [G; OUT_189]) }; __ret } else { aiur_fn_189(__args, record, io_buffer, __cu)? } };
-            let __v_11: G = __r_arr[0];
-            let __v_12: G = __r_arr[1];
-            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).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_13: G = __loaded[0];
-            let __v_14: G = __loaded[1];
-            let __v_15: G = __loaded[2];
-            let __v_16: G = __loaded[3];
-            match __v_13.as_canonical_u64() {
-              2u64 => {
-                let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_1, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } else { aiur_fn_528(__args, record, io_buffer, __cu)? } };
-                let __v_17: G = __r_arr[0];
-                match __v_17.as_canonical_u64() {
+            let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[258].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_258] = unsafe { *(result.output.as_ptr() as *const [G; OUT_258]) }; __ret } else { aiur_fn_258(__args, record, io_buffer, __cu)? } };
+            let __v_7: G = __r_arr[0];
+            let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; 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: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].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];
+            let __v_18: G = __loaded[10];
+            let __v_19: G = __loaded[11];
+            let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[258].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_258] = unsafe { *(result.output.as_ptr() as *const [G; OUT_258]) }; __ret } else { aiur_fn_258(__args, record, io_buffer, __cu)? } };
+            let __v_20: G = __r_arr[0];
+            let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_20.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+            let __v_21: G = __loaded[0];
+            let __v_22: G = __loaded[1];
+            let __v_23: G = __loaded[2];
+            let __v_24: G = __loaded[3];
+            let __v_25: G = __loaded[4];
+            let __v_26: G = __loaded[5];
+            let __v_27: G = __loaded[6];
+            let __v_28: G = __loaded[7];
+            let __v_29: G = __loaded[8];
+            let __v_30: G = __loaded[9];
+            let __v_31: G = __loaded[10];
+            let __v_32: G = __loaded[11];
+            let __r_arr: [G; OUT_433] = { let __args: [G; IN_433] = [__v_0, __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_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[433].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_433] = unsafe { *(result.output.as_ptr() as *const [G; OUT_433]) }; __ret } else { aiur_fn_433(__args, record, io_buffer, __cu)? } };
+            let __v_33: G = __r_arr[0];
+            let __v_34: G = __r_arr[1];
+            let __r_arr: [G; OUT_433] = { let __args: [G; IN_433] = [__v_1, __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_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[433].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_433] = unsafe { *(result.output.as_ptr() as *const [G; OUT_433]) }; __ret } else { aiur_fn_433(__args, record, io_buffer, __cu)? } };
+            let __v_35: G = __r_arr[0];
+            let __v_36: G = __r_arr[1];
+            match __v_33.as_canonical_u64() {
+              1u64 => {
+                match __v_35.as_canonical_u64() {
                   1u64 => {
-                    let __ret: [G; OUT_527] = [];
-                    record.function_queries[527].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_34, __v_36, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } };
+                    let __v_37: G = __r_arr[0];
+                    let __ret: [G; OUT_431] = [__v_37];
+                    record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
-                  0u64 => {
-                    let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_3, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-                    let __v_18: G = __r_arr[0];
-                    let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].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];
-                    match __v_19.as_canonical_u64() {
-                      5u64 => {
-                        let __r_arr: [G; OUT_796] = { let __args: [G; IN_796] = [__v_12, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[796].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_796] = unsafe { *(result.output.as_ptr() as *const [G; OUT_796]) }; __ret } else { aiur_fn_796(__args, record, io_buffer, __cu)? } };
-                        let __v_30: G = __r_arr[0];
-                        let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_1, __v_26, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } else { aiur_fn_534(__args, record, io_buffer, __cu)? } };
-                        let __v_31: G = __r_arr[0];
-                        let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_30, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } else { aiur_fn_533(__args, record, io_buffer, __cu)? } };
-                        let __v_32: G = __r_arr[0];
-                        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() });
-                        }
-                        let __r_arr: [G; OUT_536] = { let __args: [G; IN_536] = [__v_24, __v_12, __v_31, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[536].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_536] = unsafe { *(result.output.as_ptr() as *const [G; OUT_536]) }; __ret } else { aiur_fn_536(__args, record, io_buffer, __cu)? } };
-                        let __ret: [G; OUT_527] = [];
-                        record.function_queries[527].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                        return Ok(__ret);
-                      },
-                      _ => {
-                        let __v_30: G = G::from_u64(0);
-                        let __v_31: G = G::from_u64(1);
-                        if (__v_30 != __v_31) {
-                          return Err(ExecError::AssertEqMismatch { lhs: __v_30.as_canonical_u64(), rhs: __v_31.as_canonical_u64() });
-                        }
-                        let __ret: [G; OUT_527] = [];
-                        record.function_queries[527].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                        return Ok(__ret);
-                      },
-                    }
+                  _ => {
+                    let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_34, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } };
+                    let __v_37: G = __r_arr[0];
+                    let __ret: [G; OUT_431] = [__v_37];
+                    record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
+                  },
+                }
+              },
+              0u64 => {
+                match __v_35.as_canonical_u64() {
+                  1u64 => {
+                    let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_0, __v_36, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } };
+                    let __v_37: G = __r_arr[0];
+                    let __ret: [G; OUT_431] = [__v_37];
+                    record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
                   },
                   _ => {
-                    return Err(ExecError::MatchNoCase(__v_17.as_canonical_u64()));
+                    let __v_37: G = G::from_u64(0);
+                    let __ret: [G; OUT_431] = [__v_37];
+                    record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
                   },
                 }
               },
               _ => {
-                let __v_17: G = G::from_u64(0);
-                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() });
-                }
-                let __ret: [G; OUT_527] = [];
-                record.function_queries[527].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
+                return Err(ExecError::MatchNoCase(__v_33.as_canonical_u64()));
               },
             }
           },
@@ -46568,240 +37774,185 @@ fn aiur_fn_527(
   })
 }
 
-const INPUT_SIZE_528: usize = 2;
-const IN_528: usize = 2;
-const OUT_528: usize = 1;
-fn aiur_fn_528(
-  inp: [G; IN_528],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_528], 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_528] = [__v_5];
-        record.function_queries[528].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __v_5: G = (__v_3 - __v_1);
-        match __v_5.as_canonical_u64() {
-          0u64 => {
-            let __v_6: G = G::from_u64(1);
-            let __ret: [G; OUT_528] = [__v_6];
-            record.function_queries[528].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } else { aiur_fn_528(__args, record, io_buffer, __cu)? } };
-            let __v_6: G = __r_arr[0];
-            let __ret: [G; OUT_528] = [__v_6];
-            record.function_queries[528].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-        }
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_529: usize = 2;
-const IN_529: usize = 2;
-const OUT_529: usize = 1;
-fn aiur_fn_529(
-  inp: [G; IN_529],
+const INPUT_SIZE_432: usize = 1;
+const IN_432: usize = 1;
+const OUT_432: usize = 2;
+fn aiur_fn_432(
+  inp: [G; IN_432],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_529], ExecError> {
+) -> Result<[G; OUT_432], 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_778] = { let __args: [G; IN_778] = [__v_1, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-    let __v_2: G = __r_arr[0];
-    let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr };
+    let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[106].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_106] = unsafe { *(result.output.as_ptr() as *const [G; OUT_106]) }; __ret } else { aiur_fn_106(__args, record, io_buffer, __cu)? } };
+    let __v_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    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_3: G = __loaded[0];
     let __v_4: G = __loaded[1];
     let __v_5: G = __loaded[2];
     let __v_6: G = __loaded[3];
-    let __v_7: G = __loaded[4];
-    let __v_8: G = __loaded[5];
-    let __v_9: G = __loaded[6];
-    let __v_10: G = __loaded[7];
-    let __v_11: G = __loaded[8];
-    let __v_12: G = __loaded[9];
-    let __v_13: G = __loaded[10];
     match __v_3.as_canonical_u64() {
-      5u64 => {
-        let __r_arr: [G; OUT_559] = { let __args: [G; IN_559] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[559].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_559] = unsafe { *(result.output.as_ptr() as *const [G; OUT_559]) }; __ret } else { aiur_fn_559(__args, record, io_buffer, __cu)? } };
-        let __v_14: G = __r_arr[0];
-        let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_8, __v_6, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } else { aiur_fn_530(__args, record, io_buffer, __cu)? } };
-        let __v_15: G = __r_arr[0];
-        let __ret: [G; OUT_529] = [__v_15];
-        record.function_queries[529].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+      2u64 => {
+        let __v_7: G = G::from_u64(1);
+        let __ret: [G; OUT_432] = [__v_4, __v_7];
+        record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
+        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 __v_13: G = G::from_u64(0);
         let __v_14: G = G::from_u64(0);
-        let __ret: [G; OUT_529] = [__v_14];
-        record.function_queries[529].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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 __v_24: G = G::from_u64(0);
+        let __v_25: G = G::from_u64(0);
+        let __v_26: G = G::from_u64(0);
+        let __v_27: G = G::from_u64(0);
+        let __v_28: G = G::from_u64(0);
+        let __v_29: G = G::from_u64(0);
+        let __v_30: G = G::from_u64(0);
+        let __v_31: G = G::from_u64(0);
+        let __v_32: G = G::from_u64(0);
+        let __v_33: G = G::from_u64(0);
+        let __v_34: G = G::from_u64(0);
+        let __v_35: G = G::from_u64(0);
+        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 = { let __values: [G; 32] = [__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, __v_37, __v_38]; 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_40: G = G::from_u64(0);
+        let __ret: [G; OUT_432] = [__v_39, __v_40];
+        record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_530: usize = 4;
-const IN_530: usize = 4;
-const OUT_530: usize = 1;
-fn aiur_fn_530(
-  inp: [G; IN_530],
+const INPUT_SIZE_433: usize = 14;
+const IN_433: usize = 14;
+const OUT_433: usize = 2;
+fn aiur_fn_433(
+  inp: [G; IN_433],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_530], ExecError> {
+) -> Result<[G; OUT_433], 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_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_4: G = __loaded[0];
-    let __v_5: G = __loaded[1];
-    let __v_6: G = __loaded[2];
-    match __v_4.as_canonical_u64() {
+    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];
+    match __v_1.as_canonical_u64() {
       1u64 => {
-        let __v_7: G = G::from_u64(0);
-        let __ret: [G; OUT_530] = [__v_7];
-        record.function_queries[530].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
+        let __r_arr: [G; OUT_430] = { let __args: [G; IN_430] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[430].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_430] = unsafe { *(result.output.as_ptr() as *const [G; OUT_430]) }; __ret } else { aiur_fn_430(__args, record, io_buffer, __cu)? } };
+        let __v_14: G = __r_arr[0];
+        let __v_15: G = __r_arr[1];
+        match __v_14.as_canonical_u64() {
+          1u64 => {
+            let __v_16: G = G::from_u64(1);
+            let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_15, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = unsafe { *(result.output.as_ptr() as *const [G; OUT_377]) }; __ret } else { aiur_fn_377(__args, record, io_buffer, __cu)? } };
+            let __v_17: G = __r_arr[0];
+            let __ret: [G; OUT_433] = [__v_16, __v_17];
+            record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            let __v_16: G = G::from_u64(0);
+            let __ret: [G; OUT_433] = [__v_16, __v_0];
+            record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+        }
       },
-      0u64 => {
-        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-        let __v_7: G = __r_arr[0];
-        let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].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];
-        let __v_18: G = __loaded[10];
-        match __v_8.as_canonical_u64() {
-          6u64 => {
-            let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_10, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } else { aiur_fn_524(__args, record, io_buffer, __cu)? } };
-            let __v_19: G = __r_arr[0];
-            let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_19, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } else { aiur_fn_531(__args, record, io_buffer, __cu)? } };
-            let __v_20: G = __r_arr[0];
-            match __v_20.as_canonical_u64() {
-              1u64 => {
-                let __v_21: G = G::from_u64(1);
-                let __ret: [G; OUT_530] = [__v_21];
-                record.function_queries[530].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              0u64 => {
-                let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } else { aiur_fn_530(__args, record, io_buffer, __cu)? } };
-                let __v_21: G = __r_arr[0];
-                let __ret: [G; OUT_530] = [__v_21];
-                record.function_queries[530].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              _ => {
-                return Err(ExecError::MatchNoCase(__v_20.as_canonical_u64()));
-              },
-            }
+      2u64 => {
+        let __r_arr: [G; OUT_430] = { let __args: [G; IN_430] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[430].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_430] = unsafe { *(result.output.as_ptr() as *const [G; OUT_430]) }; __ret } else { aiur_fn_430(__args, record, io_buffer, __cu)? } };
+        let __v_14: G = __r_arr[0];
+        let __v_15: G = __r_arr[1];
+        match __v_14.as_canonical_u64() {
+          1u64 => {
+            let __v_16: G = G::from_u64(1);
+            let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_15, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = unsafe { *(result.output.as_ptr() as *const [G; OUT_377]) }; __ret } else { aiur_fn_377(__args, record, io_buffer, __cu)? } };
+            let __v_17: G = __r_arr[0];
+            let __ret: [G; OUT_433] = [__v_16, __v_17];
+            record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } else { aiur_fn_530(__args, record, io_buffer, __cu)? } };
-            let __v_19: G = __r_arr[0];
-            let __ret: [G; OUT_530] = [__v_19];
-            record.function_queries[530].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __v_16: G = G::from_u64(0);
+            let __ret: [G; OUT_433] = [__v_16, __v_0];
+            record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
+        let __v_14: G = G::from_u64(0);
+        let __ret: [G; OUT_433] = [__v_14, __v_0];
+        record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_531: usize = 2;
-const IN_531: usize = 2;
-const OUT_531: usize = 1;
-fn aiur_fn_531(
-  inp: [G; IN_531],
+const INPUT_SIZE_434: usize = 2;
+const IN_434: usize = 2;
+const OUT_434: usize = 1;
+fn aiur_fn_434(
+  inp: [G; IN_434],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_531], ExecError> {
+) -> Result<[G; OUT_434], 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() {
-      5u64 => {
-        let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } else { aiur_fn_532(__args, record, io_buffer, __cu)? } };
-        let __v_6: G = __r_arr[0];
-        match __v_6.as_canonical_u64() {
-          1u64 => {
-            let __v_7: G = G::from_u64(1);
-            let __ret: [G; OUT_531] = [__v_7];
-            record.function_queries[531].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          0u64 => {
-            let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } else { aiur_fn_531(__args, record, io_buffer, __cu)? } };
-            let __v_7: G = __r_arr[0];
-            let __ret: [G; OUT_531] = [__v_7];
-            record.function_queries[531].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64()));
-          },
-        }
-      },
-      _ => {
-        let __v_6: G = G::from_u64(0);
-        let __ret: [G; OUT_531] = [__v_6];
-        record.function_queries[531].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-    }
+    let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } };
+    let __v_2: G = __r_arr[0];
+    let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } else { aiur_fn_324(__args, record, io_buffer, __cu)? } };
+    let __v_3: G = __r_arr[0];
+    let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } else { aiur_fn_435(__args, record, io_buffer, __cu)? } };
+    let __v_4: G = __r_arr[0];
+    let __ret: [G; OUT_434] = [__v_4];
+    record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_532: usize = 2;
-const IN_532: usize = 2;
-const OUT_532: usize = 1;
-fn aiur_fn_532(
-  inp: [G; IN_532],
+const INPUT_SIZE_435: usize = 2;
+const IN_435: usize = 2;
+const OUT_435: usize = 1;
+fn aiur_fn_435(
+  inp: [G; IN_435],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_532], ExecError> {
+) -> Result<[G; OUT_435], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -46812,340 +37963,247 @@ fn aiur_fn_532(
     let __v_5: G = __loaded[3];
     match __v_2.as_canonical_u64() {
       0u64 => {
-        let __v_6: G = G::from_u64(0);
-        let __ret: [G; OUT_532] = [__v_6];
-        record.function_queries[532].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = unsafe { *(result.output.as_ptr() as *const [G; OUT_385]) }; __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } };
+        let __v_6: G = __r_arr[0];
+        let __ret: [G; OUT_435] = [__v_6];
+        record.function_queries[435].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
-        let __v_6: G = G::from_u64(0);
-        let __ret: [G; OUT_532] = [__v_6];
-        record.function_queries[532].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __v_6: G = G::from_u64(1);
+        let __v_7: G = G::from_u64(1);
+        let __v_8: G = G::from_u64(0);
+        let __v_9: G = { let __values: [G; 3] = [__v_7, __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 __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[304].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_304] = unsafe { *(result.output.as_ptr() as *const [G; OUT_304]) }; __ret } else { aiur_fn_304(__args, record, io_buffer, __cu)? } };
+        let __v_10: G = __r_arr[0];
+        let __v_11: G = G::from_u64(0);
+        let __v_12: G = { let __values: [G; 4] = [__v_6, __v_10, __v_11, __v_11]; 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_435] = [__v_12];
+        record.function_queries[435].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } else { aiur_fn_528(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[258].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_258] = unsafe { *(result.output.as_ptr() as *const [G; OUT_258]) }; __ret } else { aiur_fn_258(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
-        let __ret: [G; OUT_532] = [__v_6];
-        record.function_queries[532].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; 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: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].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];
+        let __v_17: G = __loaded[10];
+        let __v_18: G = __loaded[11];
+        let __r_arr: [G; OUT_386] = { let __args: [G; IN_386] = [__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[386].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_386] = unsafe { *(result.output.as_ptr() as *const [G; OUT_386]) }; __ret } else { aiur_fn_386(__args, record, io_buffer, __cu)? } };
+        let __v_19: G = __r_arr[0];
+        let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } else { aiur_fn_711(__args, record, io_buffer, __cu)? } };
+        let __v_20: G = __r_arr[0];
+        let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__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[387].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_387] = unsafe { *(result.output.as_ptr() as *const [G; OUT_387]) }; __ret } else { aiur_fn_387(__args, record, io_buffer, __cu)? } };
+        let __v_21: G = __r_arr[0];
+        if (__v_20 != __v_19) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_20.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: Some("Const applied to wrong number of universe levels".to_string()) });
+        }
+        let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_21, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } else { aiur_fn_307(__args, record, io_buffer, __cu)? } };
+        let __v_22: G = __r_arr[0];
+        let __ret: [G; OUT_435] = [__v_22];
+        record.function_queries[435].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } else { aiur_fn_532(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[106].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_106] = unsafe { *(result.output.as_ptr() as *const [G; OUT_106]) }; __ret } else { aiur_fn_106(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
-        match __v_6.as_canonical_u64() {
-          1u64 => {
-            let __v_7: G = G::from_u64(1);
-            let __ret: [G; OUT_532] = [__v_7];
-            record.function_queries[532].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          0u64 => {
-            let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } else { aiur_fn_532(__args, record, io_buffer, __cu)? } };
-            let __v_7: G = __r_arr[0];
-            let __ret: [G; OUT_532] = [__v_7];
-            record.function_queries[532].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64()));
-          },
-        }
+        let __v_7: G = __r_arr[1];
+        let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[434].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_434] = unsafe { *(result.output.as_ptr() as *const [G; OUT_434]) }; __ret } else { aiur_fn_434(__args, record, io_buffer, __cu)? } };
+        let __v_8: G = __r_arr[0];
+        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_436] = { let __args: [G; IN_436] = [__v_8, __v_7, __v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[436].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_436] = unsafe { *(result.output.as_ptr() as *const [G; OUT_436]) }; __ret } else { aiur_fn_436(__args, record, io_buffer, __cu)? } };
+        let __v_12: G = __r_arr[0];
+        let __ret: [G; OUT_435] = [__v_12];
+        record.function_queries[435].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
       4u64 => {
-        let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } else { aiur_fn_532(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[444].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_444] = unsafe { *(result.output.as_ptr() as *const [G; OUT_444]) }; __ret } else { aiur_fn_444(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
-        match __v_6.as_canonical_u64() {
-          1u64 => {
-            let __v_7: G = G::from_u64(1);
-            let __ret: [G; OUT_532] = [__v_7];
-            record.function_queries[532].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          0u64 => {
-            let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } else { aiur_fn_532(__args, record, io_buffer, __cu)? } };
-            let __v_7: G = __r_arr[0];
-            let __ret: [G; OUT_532] = [__v_7];
-            record.function_queries[532].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64()));
-          },
-        }
+        let __v_7: G = G::from_u64(0);
+        let __v_8: G = { let __values: [G; 3] = [__v_7, __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_434] = { let __args: [G; IN_434] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[434].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_434] = unsafe { *(result.output.as_ptr() as *const [G; OUT_434]) }; __ret } else { aiur_fn_434(__args, record, io_buffer, __cu)? } };
+        let __v_9: G = __r_arr[0];
+        let __v_10: G = G::from_u64(5);
+        let __v_11: G = G::from_u64(0);
+        let __v_12: G = { let __values: [G; 4] = [__v_10, __v_3, __v_9, __v_11]; 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_435] = [__v_12];
+        record.function_queries[435].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
       5u64 => {
-        let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } else { aiur_fn_532(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[444].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_444] = unsafe { *(result.output.as_ptr() as *const [G; OUT_444]) }; __ret } else { aiur_fn_444(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
-        match __v_6.as_canonical_u64() {
-          1u64 => {
-            let __v_7: G = G::from_u64(1);
-            let __ret: [G; OUT_532] = [__v_7];
-            record.function_queries[532].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          0u64 => {
-            let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } else { aiur_fn_532(__args, record, io_buffer, __cu)? } };
-            let __v_7: G = __r_arr[0];
-            let __ret: [G; OUT_532] = [__v_7];
-            record.function_queries[532].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64()));
-          },
-        }
+        let __v_7: G = G::from_u64(0);
+        let __v_8: G = { let __values: [G; 3] = [__v_7, __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_444] = { let __args: [G; IN_444] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[444].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_444] = unsafe { *(result.output.as_ptr() as *const [G; OUT_444]) }; __ret } else { aiur_fn_444(__args, record, io_buffer, __cu)? } };
+        let __v_9: G = __r_arr[0];
+        let __v_10: G = G::from_u64(1);
+        let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[303].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_303] = unsafe { *(result.output.as_ptr() as *const [G; OUT_303]) }; __ret } else { aiur_fn_303(__args, record, io_buffer, __cu)? } };
+        let __v_11: G = __r_arr[0];
+        let __v_12: G = G::from_u64(0);
+        let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_12, __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_435] = [__v_13];
+        record.function_queries[435].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
       6u64 => {
-        let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } else { aiur_fn_532(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[444].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_444] = unsafe { *(result.output.as_ptr() as *const [G; OUT_444]) }; __ret } else { aiur_fn_444(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
-        match __v_6.as_canonical_u64() {
-          1u64 => {
-            let __v_7: G = G::from_u64(1);
-            let __ret: [G; OUT_532] = [__v_7];
-            record.function_queries[532].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          0u64 => {
-            let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } else { aiur_fn_532(__args, record, io_buffer, __cu)? } };
-            let __v_7: G = __r_arr[0];
-            match __v_7.as_canonical_u64() {
-              1u64 => {
-                let __v_8: G = G::from_u64(1);
-                let __ret: [G; OUT_532] = [__v_8];
-                record.function_queries[532].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              0u64 => {
-                let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } else { aiur_fn_532(__args, record, io_buffer, __cu)? } };
-                let __v_8: G = __r_arr[0];
-                let __ret: [G; OUT_532] = [__v_8];
-                record.function_queries[532].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              _ => {
-                return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64()));
-              },
-            }
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64()));
-          },
-        }
-      },
-      7u64 => {
-        let __v_6: G = G::from_u64(0);
-        let __ret: [G; OUT_532] = [__v_6];
-        record.function_queries[532].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_4, __v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[445].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_445] = unsafe { *(result.output.as_ptr() as *const [G; OUT_445]) }; __ret } else { aiur_fn_445(__args, record, io_buffer, __cu)? } };
+        let __v_7: G = G::from_u64(0);
+        let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_5, __v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[331].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_331] = unsafe { *(result.output.as_ptr() as *const [G; OUT_331]) }; __ret } else { aiur_fn_331(__args, record, io_buffer, __cu)? } };
+        let __v_8: G = __r_arr[0];
+        let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[434].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_434] = unsafe { *(result.output.as_ptr() as *const [G; OUT_434]) }; __ret } else { aiur_fn_434(__args, record, io_buffer, __cu)? } };
+        let __v_9: G = __r_arr[0];
+        let __ret: [G; OUT_435] = [__v_9];
+        record.function_queries[435].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      8u64 => {
-        let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } else { aiur_fn_532(__args, record, io_buffer, __cu)? } };
+      7u64 => {
+        let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[437].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_437] = unsafe { *(result.output.as_ptr() as *const [G; OUT_437]) }; __ret } else { aiur_fn_437(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
-        let __ret: [G; OUT_532] = [__v_6];
-        record.function_queries[532].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_533: usize = 2;
-const IN_533: usize = 2;
-const OUT_533: usize = 1;
-fn aiur_fn_533(
-  inp: [G; IN_533],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_533], 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_533] = [__v_5];
-        record.function_queries[533].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_435] = [__v_6];
+        record.function_queries[435].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } else { aiur_fn_532(__args, record, io_buffer, __cu)? } };
-        let __v_5: G = __r_arr[0];
-        match __v_5.as_canonical_u64() {
-          1u64 => {
-            let __v_6: G = G::from_u64(1);
-            let __ret: [G; OUT_533] = [__v_6];
-            record.function_queries[533].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          0u64 => {
-            let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } else { aiur_fn_533(__args, record, io_buffer, __cu)? } };
-            let __v_6: G = __r_arr[0];
-            let __ret: [G; OUT_533] = [__v_6];
-            record.function_queries[533].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
-          },
-        }
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_534: usize = 3;
-const IN_534: usize = 3;
-const OUT_534: usize = 1;
-fn aiur_fn_534(
-  inp: [G; IN_534],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_534], 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 = G::from_u64(0);
-    let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } else { aiur_fn_535(__args, record, io_buffer, __cu)? } };
-    let __v_4: G = __r_arr[0];
-    let __ret: [G; OUT_534] = [__v_4];
-    record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
+      8u64 => {
+        let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_3, __v_4, __v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[443].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_443] = unsafe { *(result.output.as_ptr() as *const [G; OUT_443]) }; __ret } else { aiur_fn_443(__args, record, io_buffer, __cu)? } };
+        let __v_6: G = __r_arr[0];
+        let __ret: [G; OUT_435] = [__v_6];
+        record.function_queries[435].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
   })
 }
 
-const INPUT_SIZE_535: usize = 4;
-const IN_535: usize = 4;
-const OUT_535: usize = 1;
-fn aiur_fn_535(
-  inp: [G; IN_535],
+const INPUT_SIZE_436: usize = 4;
+const IN_436: usize = 4;
+const OUT_436: usize = 1;
+fn aiur_fn_436(
+  inp: [G; IN_436],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_535], ExecError> {
+) -> Result<[G; OUT_436], 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_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 __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 __ret: [G; OUT_535] = [__v_0];
-        record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
+        let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } else { aiur_fn_711(__args, record, io_buffer, __cu)? } };
+        let __v_7: G = __r_arr[0];
+        match __v_7.as_canonical_u64() {
+          0u64 => {
+            let __ret: [G; OUT_436] = [__v_0];
+            record.function_queries[436].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            let __v_8: G = G::from_u64(0);
+            let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_0, __v_2, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } else { aiur_fn_335(__args, record, io_buffer, __cu)? } };
+            let __v_9: G = __r_arr[0];
+            let __ret: [G; OUT_436] = [__v_9];
+            record.function_queries[436].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+        }
       },
       0u64 => {
-        let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr };
+        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_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];
-        let __v_17: G = __loaded[10];
         match __v_7.as_canonical_u64() {
           5u64 => {
-            let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_18: G = __r_arr[0];
-            let __v_19: G = G::from_u64(1);
-            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 __v_24: G = G::from_u64(0);
-            let __v_25: G = G::from_u64(0);
-            let __v_26: G = G::from_u64(0);
-            let __v_27: G = G::from_u64(0);
-            let __v_28: G = G::from_u64(0);
-            let __v_29: G = G::from_u64(0);
-            let __v_30: G = G::from_u64(0);
-            let __v_31: G = G::from_u64(0);
-            let __v_32: G = G::from_u64(0);
-            let __v_33: G = G::from_u64(0);
-            let __v_34: G = G::from_u64(0);
-            let __v_35: G = G::from_u64(0);
-            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 = 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 = G::from_u64(0);
-            let __v_51: G = G::from_u64(0);
-            let __v_52: G = { let __values: [G; 32] = [__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]; 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_122] = { let __args: [G; IN_122] = [__v_1, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_53: G = __r_arr[0];
-            let __v_54: G = (__v_19 - __v_53);
-            let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } else { aiur_fn_528(__args, record, io_buffer, __cu)? } };
-            let __v_55: G = __r_arr[0];
-            let __v_56: G = G::from_u64(1);
-            let __v_57: G = (__v_56 - __v_55);
-            let __v_58: G = (__v_54 * __v_57);
-            let __v_59: G = (__v_18 * __v_58);
-            match __v_59.as_canonical_u64() {
-              1u64 => {
-                let __v_60: G = G::from_u64(0);
-                let __v_61: G = { let __values: [G; 3] = [__v_60, __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_62: G = G::from_u64(1);
-                let __v_63: G = (__v_3 + __v_62);
-                let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_61, __v_1, __v_6, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } else { aiur_fn_535(__args, record, io_buffer, __cu)? } };
-                let __v_64: G = __r_arr[0];
-                let __ret: [G; OUT_535] = [__v_64];
-                record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              0u64 => {
-                let __v_60: G = G::from_u64(1);
-                let __v_61: G = (__v_3 + __v_60);
-                let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_0, __v_1, __v_6, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } else { aiur_fn_535(__args, record, io_buffer, __cu)? } };
-                let __v_62: G = __r_arr[0];
-                let __ret: [G; OUT_535] = [__v_62];
-                record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } else { aiur_fn_711(__args, record, io_buffer, __cu)? } };
+            let __v_11: G = __r_arr[0];
+            let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_11.as_canonical_u64() {
+  0u64 => {
+    break '__mc_0 [__v_8];
+  },
+  _ => {
+    let __v_12: G = G::from_u64(0);
+    let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_8, __v_2, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } else { aiur_fn_335(__args, record, io_buffer, __cu)? } };
+    let __v_13: G = __r_arr[0];
+    break '__mc_0 [__v_13];
+  },
+}
+ };
+            let __v_12: G = __mc_out___mc_0[0];
+            let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_5, __v_12, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[445].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_445] = unsafe { *(result.output.as_ptr() as *const [G; OUT_445]) }; __ret } else { aiur_fn_445(__args, record, io_buffer, __cu)? } };
+            let __v_13: G = G::from_u64(0);
+            let __v_14: G = { let __values: [G; 3] = [__v_13, __v_5, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_436] = { let __args: [G; IN_436] = [__v_9, __v_6, __v_14, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[436].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_436] = unsafe { *(result.output.as_ptr() as *const [G; OUT_436]) }; __ret } else { aiur_fn_436(__args, record, io_buffer, __cu)? } };
+            let __v_15: G = __r_arr[0];
+            let __ret: [G; OUT_436] = [__v_15];
+            record.function_queries[436].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } else { aiur_fn_711(__args, record, io_buffer, __cu)? } };
+            let __v_11: G = __r_arr[0];
+            let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_11.as_canonical_u64() {
+  0u64 => {
+    break '__mc_1 [__v_0];
+  },
+  _ => {
+    let __v_12: G = G::from_u64(0);
+    let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_0, __v_2, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } else { aiur_fn_335(__args, record, io_buffer, __cu)? } };
+    let __v_13: G = __r_arr[0];
+    break '__mc_1 [__v_13];
+  },
+}
+ };
+            let __v_12: G = __mc_out___mc_1[0];
+            let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_12, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = unsafe { *(result.output.as_ptr() as *const [G; OUT_377]) }; __ret } else { aiur_fn_377(__args, record, io_buffer, __cu)? } };
+            let __v_13: 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_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: 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() {
+              5u64 => {
+                let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_5, __v_15, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[445].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_445] = unsafe { *(result.output.as_ptr() as *const [G; OUT_445]) }; __ret } else { aiur_fn_445(__args, record, io_buffer, __cu)? } };
+                let __v_18: G = G::from_u64(0);
+                let __v_19: G = G::from_u64(1);
+                let __v_20: G = G::from_u64(1);
+                let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __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_18, __v_5, __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 __r_arr: [G; OUT_436] = { let __args: [G; IN_436] = [__v_16, __v_6, __v_22, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[436].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_436] = unsafe { *(result.output.as_ptr() as *const [G; OUT_436]) }; __ret } else { aiur_fn_436(__args, record, io_buffer, __cu)? } };
+                let __v_23: G = __r_arr[0];
+                let __ret: [G; OUT_436] = [__v_23];
+                record.function_queries[436].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                return Err(ExecError::MatchNoCase(__v_59.as_canonical_u64()));
+                return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64()));
               },
             }
           },
-          _ => {
-            let __v_18: G = G::from_u64(1);
-            let __v_19: G = (__v_3 + __v_18);
-            let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_0, __v_1, __v_6, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } else { aiur_fn_535(__args, record, io_buffer, __cu)? } };
-            let __v_20: G = __r_arr[0];
-            let __ret: [G; OUT_535] = [__v_20];
-            record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
         }
       },
       _ => {
@@ -47155,217 +38213,140 @@ fn aiur_fn_535(
   })
 }
 
-const INPUT_SIZE_536: usize = 5;
-const IN_536: usize = 5;
-const OUT_536: usize = 0;
-fn aiur_fn_536(
-  inp: [G; IN_536],
+const INPUT_SIZE_437: usize = 2;
+const IN_437: usize = 2;
+const OUT_437: usize = 1;
+fn aiur_fn_437(
+  inp: [G; IN_437],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_536], ExecError> {
+) -> Result<[G; OUT_437], 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 __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_5: G = __loaded[0];
-    let __v_6: G = __loaded[1];
-    let __v_7: G = __loaded[2];
-    match __v_5.as_canonical_u64() {
-      1u64 => {
-        let __ret: [G; OUT_536] = [];
-        record.function_queries[536].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __v_2: G = G::from_u64(2);
+        let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[345].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_345] = unsafe { *(result.output.as_ptr() as *const [G; OUT_345]) }; __ret } else { aiur_fn_345(__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 __v_7: G = G::from_u64(0);
+        let __v_8: G = { let __values: [G; 4] = [__v_2, __v_3, __v_6, __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_437] = [__v_8];
+        record.function_queries[437].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-        let __v_8: G = __r_arr[0];
-        let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].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 __v_17: G = __loaded[8];
-        let __v_18: G = __loaded[9];
-        let __v_19: G = __loaded[10];
-        match __v_9.as_canonical_u64() {
-          6u64 => {
-            let __v_20: G = G::from_u64(1);
-            let __v_21: G = G::from_u64(1);
-            let __v_22: G = { let __values: [G; 3] = [__v_20, __v_21, __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 __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_11, __v_14, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } else { aiur_fn_525(__args, record, io_buffer, __cu)? } };
-            let __v_23: G = __r_arr[0];
-            let __v_24: G = __r_arr[1];
-            let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = [__v_23, __v_2, __v_24, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[526].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_526] = unsafe { *(result.output.as_ptr() as *const [G; OUT_526]) }; __ret } else { aiur_fn_526(__args, record, io_buffer, __cu)? } };
-            let __r_arr: [G; OUT_536] = { let __args: [G; IN_536] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[536].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_536] = unsafe { *(result.output.as_ptr() as *const [G; OUT_536]) }; __ret } else { aiur_fn_536(__args, record, io_buffer, __cu)? } };
-            let __ret: [G; OUT_536] = [];
-            record.function_queries[536].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            let __r_arr: [G; OUT_536] = { let __args: [G; IN_536] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[536].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_536] = unsafe { *(result.output.as_ptr() as *const [G; OUT_536]) }; __ret } else { aiur_fn_536(__args, record, io_buffer, __cu)? } };
-            let __ret: [G; OUT_536] = [];
-            record.function_queries[536].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-        }
+      1u64 => {
+        let __v_2: G = G::from_u64(2);
+        let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { 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 = 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 __v_7: G = G::from_u64(0);
+        let __v_8: G = { let __values: [G; 4] = [__v_2, __v_3, __v_6, __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_437] = [__v_8];
+        record.function_queries[437].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
+        return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_537: usize = 4;
-const IN_537: usize = 4;
-const OUT_537: usize = 1;
-fn aiur_fn_537(
-  inp: [G; IN_537],
+const INPUT_SIZE_438: usize = 4;
+const IN_438: usize = 4;
+const OUT_438: usize = 1;
+fn aiur_fn_438(
+  inp: [G; IN_438],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_537], ExecError> {
+) -> Result<[G; OUT_438], 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_190] = { let __args: [G; IN_190] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[190].get_mut(&__args[..]) { 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_307] = { let __args: [G; IN_307] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } else { aiur_fn_307(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
-    match __v_4.as_canonical_u64() {
+    let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_4, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } };
+    let __v_5: 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_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: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].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];
+    match __v_6.as_canonical_u64() {
       1u64 => {
-        let __v_5: G = G::from_u64(1);
-        let __ret: [G; OUT_537] = [__v_5];
-        record.function_queries[537].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __v_10: G = G::from_u64(0);
+        let __v_11: G = G::from_u64(0);
+        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 __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_7, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } else { aiur_fn_295(__args, record, io_buffer, __cu)? } };
+        let __v_13: G = __r_arr[0];
+        let __ret: [G; OUT_438] = [__v_13];
+        record.function_queries[438].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { 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_5: G = __r_arr[0];
-        match __v_5.as_canonical_u64() {
-          0u64 => {
-            let __v_6: G = G::from_u64(1);
-            let __ret: [G; OUT_537] = [__v_6];
-            record.function_queries[537].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          1u64 => {
-            let __v_6: G = G::from_u64(0);
-            let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-            let __v_7: G = __r_arr[0];
-            let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-            let __v_8: G = __r_arr[0];
-            let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].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 __v_17: G = __loaded[8];
-            let __v_18: G = __loaded[9];
-            let __v_19: G = __loaded[10];
-            match __v_9.as_canonical_u64() {
-              6u64 => {
-                match __v_15.as_canonical_u64() {
-                  0u64 => {
-                    let __v_20: G = G::from_u64(1);
-                    let __ret: [G; OUT_537] = [__v_20];
-                    record.function_queries[537].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
-                  _ => {
-                    let __v_20: G = G::from_u64(1);
-                    let __v_21: G = G::from_u64(1);
-                    let __v_22: G = { let __values: [G; 3] = [__v_20, __v_21, __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 __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_11, __v_14, __v_15, __v_22, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[538].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_538] = unsafe { *(result.output.as_ptr() as *const [G; OUT_538]) }; __ret } else { aiur_fn_538(__args, record, io_buffer, __cu)? } };
-                    let __v_23: G = __r_arr[0];
-                    let __ret: [G; OUT_537] = [__v_23];
-                    record.function_queries[537].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
-                }
-              },
-              _ => {
-                return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64()));
-              },
-            }
-          },
-          _ => {
-            let __v_6: G = G::from_u64(0);
-            let __ret: [G; OUT_537] = [__v_6];
-            record.function_queries[537].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-        }
-      },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
+        let __v_10: G = G::from_u64(0);
+        let __ret: [G; OUT_438] = [__v_10];
+        record.function_queries[438].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_538: usize = 6;
-const IN_538: usize = 6;
-const OUT_538: usize = 1;
-fn aiur_fn_538(
-  inp: [G; IN_538],
+const INPUT_SIZE_439: usize = 3;
+const IN_439: usize = 3;
+const OUT_439: usize = 1;
+fn aiur_fn_439(
+  inp: [G; IN_439],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_538], ExecError> {
+) -> Result<[G; OUT_439], 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];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __v_6: G = G::from_u64(0);
-        let __v_7: G = G::from_u64(1);
-        let __v_8: G = G::from_u64(1);
-        let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __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 __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_0, __v_2, __v_6, __v_3, __v_4, __v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[539].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_539] = unsafe { *(result.output.as_ptr() as *const [G; OUT_539]) }; __ret } else { aiur_fn_539(__args, record, io_buffer, __cu)? } };
-        let __v_10: G = __r_arr[0];
-        let __ret: [G; OUT_538] = [__v_10];
-        record.function_queries[538].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = unsafe { *(result.output.as_ptr() as *const [G; OUT_377]) }; __ret } else { aiur_fn_377(__args, record, io_buffer, __cu)? } };
+        let __v_3: G = __r_arr[0];
+        let __ret: [G; OUT_439] = [__v_3];
+        record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        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_6: G = __loaded[0];
-        let __v_7: G = __loaded[1];
-        let __v_8: G = __loaded[2];
-        let __v_9: G = __loaded[3];
-        match __v_6.as_canonical_u64() {
+        let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = unsafe { *(result.output.as_ptr() as *const [G; OUT_377]) }; __ret } else { aiur_fn_377(__args, record, io_buffer, __cu)? } };
+        let __v_3: 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_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: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __v_4: G = __loaded[0];
+        let __v_5: G = __loaded[1];
+        let __v_6: G = __loaded[2];
+        let __v_7: G = __loaded[3];
+        match __v_4.as_canonical_u64() {
           5u64 => {
-            let __v_10: G = G::from_u64(0);
-            let __v_11: G = { let __values: [G; 3] = [__v_10, __v_7, __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 __v_12: G = G::from_u64(1);
-            let __v_13: G = (__v_1 - __v_12);
-            let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_8, __v_13, __v_2, __v_11, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[538].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_538] = unsafe { *(result.output.as_ptr() as *const [G; OUT_538]) }; __ret } else { aiur_fn_538(__args, record, io_buffer, __cu)? } };
-            let __v_14: G = __r_arr[0];
-            let __ret: [G; OUT_538] = [__v_14];
-            record.function_queries[538].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __v_8: G = G::from_u64(0);
+            let __v_9: G = { let __values: [G; 3] = [__v_8, __v_5, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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 = G::from_u64(1);
+            let __v_11: G = (__v_1 - __v_10);
+            let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_6, __v_11, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } };
+            let __v_12: G = __r_arr[0];
+            let __ret: [G; OUT_439] = [__v_12];
+            record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __v_10: G = G::from_u64(0);
-            let __ret: [G; OUT_538] = [__v_10];
-            record.function_queries[538].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_439] = [__v_3];
+            record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -47374,81 +38355,88 @@ fn aiur_fn_538(
   })
 }
 
-const INPUT_SIZE_539: usize = 7;
-const IN_539: usize = 7;
-const OUT_539: usize = 1;
-fn aiur_fn_539(
-  inp: [G; IN_539],
+const INPUT_SIZE_440: usize = 3;
+const IN_440: usize = 3;
+const OUT_440: usize = 0;
+fn aiur_fn_440(
+  inp: [G; IN_440],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_539], ExecError> {
+) -> Result<[G; OUT_440], 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_440] = [];
+        record.function_queries[440].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[444].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_444] = unsafe { *(result.output.as_ptr() as *const [G; OUT_444]) }; __ret } else { aiur_fn_444(__args, record, io_buffer, __cu)? } };
+        let __v_3: G = __r_arr[0];
+        let __v_4: G = G::from_u64(0);
+        let __v_5: G = G::from_u64(0);
+        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_295] = { let __args: [G; IN_295] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } else { aiur_fn_295(__args, record, io_buffer, __cu)? } };
+        let __v_7: G = __r_arr[0];
+        let __v_8: G = G::from_u64(1);
+        if (__v_7 != __v_8) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("projection on a Prop structure: field is not a Prop".to_string()) });
+        }
+        let __ret: [G; OUT_440] = [];
+        record.function_queries[440].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_441: usize = 4;
+const IN_441: usize = 4;
+const OUT_441: usize = 0;
+fn aiur_fn_441(
+  inp: [G; IN_441],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_441], 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 = (__v_1 - __v_2);
-    match __v_7.as_canonical_u64() {
+    match __v_0.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[189].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_189] = unsafe { *(result.output.as_ptr() as *const [G; OUT_189]) }; __ret } else { aiur_fn_189(__args, record, io_buffer, __cu)? } };
-        let __v_8: G = __r_arr[0];
-        let __v_9: G = __r_arr[1];
-        let __r_arr: [G; OUT_540] = { let __args: [G; IN_540] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[540].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_540] = unsafe { *(result.output.as_ptr() as *const [G; OUT_540]) }; __ret } else { aiur_fn_540(__args, record, io_buffer, __cu)? } };
-        let __v_10: G = __r_arr[0];
-        let __ret: [G; OUT_539] = [__v_10];
-        record.function_queries[539].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_441] = [];
+        record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        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_8: G = __loaded[0];
-        let __v_9: G = __loaded[1];
-        let __v_10: G = __loaded[2];
-        let __v_11: G = __loaded[3];
+        let __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[444].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_444] = unsafe { *(result.output.as_ptr() as *const [G; OUT_444]) }; __ret } else { aiur_fn_444(__args, record, io_buffer, __cu)? } };
+        let __v_4: G = __r_arr[0];
+        let __v_5: G = G::from_u64(0);
+        let __v_6: G = G::from_u64(0);
+        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 __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } else { aiur_fn_295(__args, record, io_buffer, __cu)? } };
+        let __v_8: G = __r_arr[0];
         match __v_8.as_canonical_u64() {
-          5u64 => {
-            let __r_arr: [G; OUT_465] = { let __args: [G; IN_465] = [__v_9, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[465].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_465] = unsafe { *(result.output.as_ptr() as *const [G; OUT_465]) }; __ret } else { aiur_fn_465(__args, record, io_buffer, __cu)? } };
-            let __v_12: G = __r_arr[0];
-            let __v_13: G = G::from_u64(1);
-            let __v_14: G = G::from_u64(0);
-            let __v_15: G = G::from_u64(0);
-            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_216] = { let __args: [G; IN_216] = [__v_12, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[216].get_mut(&__args[..]) { 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_17: G = __r_arr[0];
-            let __v_18: G = (__v_13 - __v_17);
-            let __v_19: G = G::from_u64(1);
-            let __v_20: G = (__v_19 - __v_2);
-            let __v_21: G = (__v_1 - __v_20);
-            let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_18.as_canonical_u64() {
-  0u64 => {
-    break '__mc_0 [__v_6];
-  },
-  _ => {
-    let __v_22: G = G::from_u64(0);
-    let __v_23: G = { let __values: [G; 3] = [__v_22, __v_21, __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 } };
-    break '__mc_0 [__v_23];
-  },
-}
- };
-            let __v_22: G = __mc_out___mc_0[0];
-            let __v_23: G = G::from_u64(0);
-            let __v_24: G = { let __values: [G; 3] = [__v_23, __v_9, __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 __v_25: G = G::from_u64(1);
-            let __v_26: G = (__v_2 + __v_25);
-            let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_10, __v_1, __v_26, __v_24, __v_4, __v_5, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[539].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_539] = unsafe { *(result.output.as_ptr() as *const [G; OUT_539]) }; __ret } else { aiur_fn_539(__args, record, io_buffer, __cu)? } };
-            let __v_27: G = __r_arr[0];
-            let __ret: [G; OUT_539] = [__v_27];
-            record.function_queries[539].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+          1u64 => {
+            let __ret: [G; OUT_441] = [];
+            record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __v_12: G = G::from_u64(0);
-            let __ret: [G; OUT_539] = [__v_12];
-            record.function_queries[539].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } };
+            let __v_9: G = __r_arr[0];
+            let __v_10: G = G::from_u64(0);
+            if (__v_9 != __v_10) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: Some("projection on a Prop structure: later fields depend on a data field".to_string()) });
+            }
+            let __ret: [G; OUT_441] = [];
+            record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -47457,1241 +38445,1417 @@ fn aiur_fn_539(
   })
 }
 
-const INPUT_SIZE_540: usize = 2;
-const IN_540: usize = 2;
-const OUT_540: usize = 1;
-fn aiur_fn_540(
-  inp: [G; IN_540],
+const INPUT_SIZE_442: usize = 7;
+const IN_442: usize = 7;
+const OUT_442: usize = 1;
+fn aiur_fn_442(
+  inp: [G; IN_442],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_540], ExecError> {
+) -> Result<[G; OUT_442], 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(1);
-        let __ret: [G; OUT_540] = [__v_5];
-        record.function_queries[540].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __r_arr: [G; OUT_541] = { let __args: [G; IN_541] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[541].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_541] = unsafe { *(result.output.as_ptr() as *const [G; OUT_541]) }; __ret } else { aiur_fn_541(__args, record, io_buffer, __cu)? } };
-        let __v_5: G = __r_arr[0];
-        match __v_5.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 __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_7: G = __loaded[0];
+    let __v_8: G = __loaded[1];
+    let __v_9: G = __loaded[2];
+    let __v_10: G = __loaded[3];
+    match __v_7.as_canonical_u64() {
+      5u64 => {
+        let __v_11: G = (__v_1 - __v_2);
+        match __v_11.as_canonical_u64() {
           0u64 => {
-            let __v_6: G = G::from_u64(0);
-            let __ret: [G; OUT_540] = [__v_6];
-            record.function_queries[540].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          1u64 => {
-            let __r_arr: [G; OUT_540] = { let __args: [G; IN_540] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[540].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_540] = unsafe { *(result.output.as_ptr() as *const [G; OUT_540]) }; __ret } else { aiur_fn_540(__args, record, io_buffer, __cu)? } };
-            let __v_6: G = __r_arr[0];
-            let __ret: [G; OUT_540] = [__v_6];
-            record.function_queries[540].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_5, __v_8, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = unsafe { *(result.output.as_ptr() as *const [G; OUT_440]) }; __ret } else { aiur_fn_440(__args, record, io_buffer, __cu)? } };
+            let __ret: [G; OUT_442] = [__v_8];
+            record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
+            let __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_5, __v_8, __v_9, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[441].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_441] = unsafe { *(result.output.as_ptr() as *const [G; OUT_441]) }; __ret } else { aiur_fn_441(__args, record, io_buffer, __cu)? } };
+            let __v_12: G = G::from_u64(8);
+            let __v_13: G = { let __values: [G; 4] = [__v_12, __v_3, __v_2, __v_4]; 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_14: G = G::from_u64(0);
+            let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_9, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[331].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_331] = unsafe { *(result.output.as_ptr() as *const [G; OUT_331]) }; __ret } else { aiur_fn_331(__args, record, io_buffer, __cu)? } };
+            let __v_15: G = __r_arr[0];
+            let __v_16: G = G::from_u64(1);
+            let __v_17: G = (__v_2 + __v_16);
+            let __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_15, __v_1, __v_17, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[442].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_442] = unsafe { *(result.output.as_ptr() as *const [G; OUT_442]) }; __ret } else { aiur_fn_442(__args, record, io_buffer, __cu)? } };
+            let __v_18: G = __r_arr[0];
+            let __ret: [G; OUT_442] = [__v_18];
+            record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
           },
         }
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+        return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_541: usize = 2;
-const IN_541: usize = 2;
-const OUT_541: usize = 1;
-fn aiur_fn_541(
-  inp: [G; IN_541],
+const INPUT_SIZE_443: usize = 4;
+const IN_443: usize = 4;
+const OUT_443: usize = 1;
+fn aiur_fn_443(
+  inp: [G; IN_443],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_541], ExecError> {
+) -> Result<[G; OUT_443], 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_541] = [__v_5];
-        record.function_queries[541].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_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: 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() {
-          0u64 => {
-            let __v_9: G = (__v_6 - __v_1);
-            match __v_9.as_canonical_u64() {
-              0u64 => {
-                let __v_10: G = G::from_u64(1);
-                let __ret: [G; OUT_541] = [__v_10];
-                record.function_queries[541].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[434].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_434] = unsafe { *(result.output.as_ptr() as *const [G; OUT_434]) }; __ret } else { aiur_fn_434(__args, record, io_buffer, __cu)? } };
+    let __v_4: G = __r_arr[0];
+    let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_4, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = unsafe { *(result.output.as_ptr() as *const [G; OUT_377]) }; __ret } else { aiur_fn_377(__args, record, io_buffer, __cu)? } };
+    let __v_5: G = __r_arr[0];
+    let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[106].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_106] = unsafe { *(result.output.as_ptr() as *const [G; OUT_106]) }; __ret } else { aiur_fn_106(__args, record, io_buffer, __cu)? } };
+    let __v_6: G = __r_arr[0];
+    let __v_7: G = __r_arr[1];
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; 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: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].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];
+    match __v_8.as_canonical_u64() {
+      2u64 => {
+        let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[258].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_258] = unsafe { *(result.output.as_ptr() as *const [G; OUT_258]) }; __ret } else { aiur_fn_258(__args, record, io_buffer, __cu)? } };
+        let __v_12: G = __r_arr[0];
+        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; 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: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+        let __v_13: G = __loaded[0];
+        let __v_14: G = __loaded[1];
+        let __v_15: G = __loaded[2];
+        let __v_16: G = __loaded[3];
+        let __v_17: G = __loaded[4];
+        let __v_18: G = __loaded[5];
+        let __v_19: G = __loaded[6];
+        let __v_20: G = __loaded[7];
+        let __v_21: G = __loaded[8];
+        let __v_22: G = __loaded[9];
+        let __v_23: G = __loaded[10];
+        let __v_24: G = __loaded[11];
+        if (__v_9 != __v_0) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_0.as_canonical_u64(), msg: Some("projection's structure type differs from the value's head".to_string()) });
+        }
+        match __v_13.as_canonical_u64() {
+          5u64 => {
+            let __v_25: G = G::from_u64(0);
+            let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_20, __v_21, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[261].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_261] = unsafe { *(result.output.as_ptr() as *const [G; OUT_261]) }; __ret } else { aiur_fn_261(__args, record, io_buffer, __cu)? } };
+            let __v_26: G = __r_arr[0];
+            let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_26.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+            let __v_27: G = __loaded[0];
+            let __v_28: G = __loaded[1];
+            let __v_29: G = __loaded[2];
+            let __v_30: G = __loaded[3];
+            let __v_31: G = __loaded[4];
+            let __v_32: G = __loaded[5];
+            let __v_33: G = __loaded[6];
+            let __v_34: G = __loaded[7];
+            let __v_35: G = __loaded[8];
+            let __v_36: G = __loaded[9];
+            let __v_37: G = __loaded[10];
+            let __v_38: G = __loaded[11];
+            let __v_39: G = G::from_u64(1);
+            if (__v_18 != __v_39) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_18.as_canonical_u64(), rhs: __v_39.as_canonical_u64(), msg: Some("projection on an inductive with more than one constructor".to_string()) });
+            }
+            match __v_27.as_canonical_u64() {
+              6u64 => {
+                let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_29, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } else { aiur_fn_307(__args, record, io_buffer, __cu)? } };
+                let __v_40: G = __r_arr[0];
+                let __r_arr: [G; OUT_391] = { let __args: [G; IN_391] = [__v_40, __v_7, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[391].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_391] = unsafe { *(result.output.as_ptr() as *const [G; OUT_391]) }; __ret } else { aiur_fn_391(__args, record, io_buffer, __cu)? } };
+                let __v_41: G = __r_arr[0];
+                let __v_42: G = (__v_16 + __v_17);
+                let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_15, __v_10, __v_42, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } else { aiur_fn_438(__args, record, io_buffer, __cu)? } };
+                let __v_43: G = __r_arr[0];
+                let __v_44: G = G::from_u64(0);
+                let __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_41, __v_1, __v_44, __v_0, __v_2, __v_43, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[442].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_442] = unsafe { *(result.output.as_ptr() as *const [G; OUT_442]) }; __ret } else { aiur_fn_442(__args, record, io_buffer, __cu)? } };
+                let __v_45: G = __r_arr[0];
+                let __ret: [G; OUT_443] = [__v_45];
+                record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_541] = { let __args: [G; IN_541] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[541].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_541] = unsafe { *(result.output.as_ptr() as *const [G; OUT_541]) }; __ret } else { aiur_fn_541(__args, record, io_buffer, __cu)? } };
-                let __v_10: G = __r_arr[0];
-                let __ret: [G; OUT_541] = [__v_10];
-                record.function_queries[541].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
+                return Err(ExecError::MatchNoCase(__v_27.as_canonical_u64()));
               },
             }
           },
           _ => {
-            let __r_arr: [G; OUT_541] = { let __args: [G; IN_541] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[541].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_541] = unsafe { *(result.output.as_ptr() as *const [G; OUT_541]) }; __ret } else { aiur_fn_541(__args, record, io_buffer, __cu)? } };
-            let __v_9: G = __r_arr[0];
-            let __ret: [G; OUT_541] = [__v_9];
-            record.function_queries[541].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
+            return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64()));
           },
         }
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+        return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_542: usize = 11;
-const IN_542: usize = 11;
-const OUT_542: usize = 1;
-fn aiur_fn_542(
-  inp: [G; IN_542],
+const INPUT_SIZE_444: usize = 2;
+const IN_444: usize = 2;
+const OUT_444: usize = 1;
+fn aiur_fn_444(
+  inp: [G; IN_444],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_542], ExecError> {
+) -> Result<[G; OUT_444], 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 __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } };
-    let __v_11: G = __r_arr[0];
-    let __v_12: G = G::from_u64(0);
-    let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_11, __v_2, __v_6, __v_7, __v_8, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[545].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_545] = unsafe { *(result.output.as_ptr() as *const [G; OUT_545]) }; __ret } else { aiur_fn_545(__args, record, io_buffer, __cu)? } };
-    let __v_13: G = __r_arr[0];
-    let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_13, __v_3, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[551].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_551] = unsafe { *(result.output.as_ptr() as *const [G; OUT_551]) }; __ret } else { aiur_fn_551(__args, record, io_buffer, __cu)? } };
-    let __v_14: G = __r_arr[0];
-    let __v_15: G = G::from_u64(2);
-    let __v_16: G = G::from_u64(0);
-    let __v_17: G = { let __values: [G; 4] = [__v_15, __v_0, __v_4, __v_16]; 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_543] = { let __args: [G; IN_543] = [__v_17, __v_6, __v_3, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[543].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_543] = unsafe { *(result.output.as_ptr() as *const [G; OUT_543]) }; __ret } else { aiur_fn_543(__args, record, io_buffer, __cu)? } };
-    let __v_18: G = __r_arr[0];
-    let __v_19: G = G::from_u64(0);
-    let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_18, __v_3, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[554].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_554] = unsafe { *(result.output.as_ptr() as *const [G; OUT_554]) }; __ret } else { aiur_fn_554(__args, record, io_buffer, __cu)? } };
-    let __v_20: G = __r_arr[0];
-    let __v_21: G = G::from_u64(1);
-    let __v_22: G = G::from_u64(0);
-    let __v_23: G = { let __values: [G; 4] = [__v_21, __v_5, __v_22, __v_22]; 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_24: G = G::from_u64(5);
-    let __v_25: G = G::from_u64(0);
-    let __v_26: G = { let __values: [G; 4] = [__v_24, __v_20, __v_23, __v_25]; 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_555] = { let __args: [G; IN_555] = [__v_26, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[555].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_555] = unsafe { *(result.output.as_ptr() as *const [G; OUT_555]) }; __ret } else { aiur_fn_555(__args, record, io_buffer, __cu)? } };
-    let __v_27: G = __r_arr[0];
-    let __ret: [G; OUT_542] = [__v_27];
-    record.function_queries[542].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
+    let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[434].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_434] = unsafe { *(result.output.as_ptr() as *const [G; OUT_434]) }; __ret } else { aiur_fn_434(__args, record, io_buffer, __cu)? } };
+    let __v_2: G = __r_arr[0];
+    let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = unsafe { *(result.output.as_ptr() as *const [G; OUT_377]) }; __ret } else { aiur_fn_377(__args, record, io_buffer, __cu)? } };
+    let __v_3: 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_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: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __v_4: G = __loaded[0];
+    let __v_5: G = __loaded[1];
+    let __v_6: G = __loaded[2];
+    let __v_7: G = __loaded[3];
+    match __v_4.as_canonical_u64() {
+      1u64 => {
+        let __ret: [G; OUT_444] = [__v_5];
+        record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
+      },
+    }
   })
 }
 
-const INPUT_SIZE_543: usize = 5;
-const IN_543: usize = 5;
-const OUT_543: usize = 1;
-fn aiur_fn_543(
-  inp: [G; IN_543],
+const INPUT_SIZE_445: usize = 3;
+const IN_445: usize = 3;
+const OUT_445: usize = 0;
+fn aiur_fn_445(
+  inp: [G; IN_445],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_543], ExecError> {
+) -> Result<[G; OUT_445], 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(0);
-        let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_0, __v_1, __v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[553].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_553] = unsafe { *(result.output.as_ptr() as *const [G; OUT_553]) }; __ret } else { aiur_fn_553(__args, record, io_buffer, __cu)? } };
-        let __v_6: G = __r_arr[0];
-        let __ret: [G; OUT_543] = [__v_6];
-        record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_0, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[544].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_544] = unsafe { *(result.output.as_ptr() as *const [G; OUT_544]) }; __ret } else { aiur_fn_544(__args, record, io_buffer, __cu)? } };
-        let __v_5: G = __r_arr[0];
-        let __ret: [G; OUT_543] = [__v_5];
-        record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
+    let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[434].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_434] = unsafe { *(result.output.as_ptr() as *const [G; OUT_434]) }; __ret } else { aiur_fn_434(__args, record, io_buffer, __cu)? } };
+    let __v_3: G = __r_arr[0];
+    let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_3, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } };
+    let __v_4: G = __r_arr[0];
+    let __v_5: G = G::from_u64(1);
+    if (__v_4 != __v_5) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_4.as_canonical_u64(), rhs: __v_5.as_canonical_u64(), msg: Some("inferred type is not def-eq to the expected type".to_string()) });
     }
+    let __ret: [G; OUT_445] = [];
+    record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_544: usize = 3;
-const IN_544: usize = 3;
-const OUT_544: usize = 1;
-fn aiur_fn_544(
-  inp: [G; IN_544],
+const INPUT_SIZE_446: usize = 0;
+const IN_446: usize = 0;
+const OUT_446: usize = 1;
+fn aiur_fn_446(
+  inp: [G; IN_446],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_544], ExecError> {
+) -> Result<[G; OUT_446], 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_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_3: G = __loaded[0];
-    let __v_4: G = __loaded[1];
-    let __v_5: G = __loaded[2];
-    match __v_3.as_canonical_u64() {
-      1u64 => {
-        let __ret: [G; OUT_544] = [__v_0];
-        record.function_queries[544].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __v_6: G = G::from_u64(0);
-        let __r_arr: [G; OUT_413] = { let __args: [G; IN_413] = [__v_4, __v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[413].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_413] = unsafe { *(result.output.as_ptr() as *const [G; OUT_413]) }; __ret } else { aiur_fn_413(__args, record, io_buffer, __cu)? } };
-        let __v_7: G = __r_arr[0];
-        let __v_8: G = G::from_u64(3);
-        let __v_9: G = G::from_u64(0);
-        let __v_10: G = { let __values: [G; 4] = [__v_8, __v_0, __v_7, __v_9]; 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_544] = { let __args: [G; IN_544] = [__v_10, __v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[544].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_544] = unsafe { *(result.output.as_ptr() as *const [G; OUT_544]) }; __ret } else { aiur_fn_544(__args, record, io_buffer, __cu)? } };
-        let __v_11: G = __r_arr[0];
-        let __ret: [G; OUT_544] = [__v_11];
-        record.function_queries[544].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
-      },
-    }
+    let __v_0: G = G::from_u64(236);
+    let __v_1: G = G::from_u64(31);
+    let __v_2: G = G::from_u64(96);
+    let __v_3: G = G::from_u64(193);
+    let __v_4: G = G::from_u64(162);
+    let __v_5: G = G::from_u64(141);
+    let __v_6: G = G::from_u64(72);
+    let __v_7: G = G::from_u64(188);
+    let __v_8: G = G::from_u64(152);
+    let __v_9: G = G::from_u64(254);
+    let __v_10: G = G::from_u64(62);
+    let __v_11: G = G::from_u64(247);
+    let __v_12: G = G::from_u64(45);
+    let __v_13: G = G::from_u64(37);
+    let __v_14: G = G::from_u64(81);
+    let __v_15: G = G::from_u64(50);
+    let __v_16: G = G::from_u64(115);
+    let __v_17: G = G::from_u64(90);
+    let __v_18: G = G::from_u64(80);
+    let __v_19: G = G::from_u64(60);
+    let __v_20: G = G::from_u64(195);
+    let __v_21: G = G::from_u64(110);
+    let __v_22: G = G::from_u64(63);
+    let __v_23: G = G::from_u64(240);
+    let __v_24: G = G::from_u64(242);
+    let __v_25: G = G::from_u64(46);
+    let __v_26: G = G::from_u64(61);
+    let __v_27: G = G::from_u64(72);
+    let __v_28: G = G::from_u64(110);
+    let __v_29: G = G::from_u64(38);
+    let __v_30: G = G::from_u64(110);
+    let __v_31: G = G::from_u64(190);
+    let __v_32: G = { let __values: [G; 32] = [__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]; 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_446] = [__v_32];
+    record.function_queries[446].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_545: usize = 6;
-const IN_545: usize = 6;
-const OUT_545: usize = 1;
-fn aiur_fn_545(
-  inp: [G; IN_545],
+const INPUT_SIZE_447: usize = 0;
+const IN_447: usize = 0;
+const OUT_447: usize = 1;
+fn aiur_fn_447(
+  inp: [G; IN_447],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_545], ExecError> {
+) -> Result<[G; OUT_447], 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];
-    match __v_1.as_canonical_u64() {
-      0u64 => {
-        let __ret: [G; OUT_545] = [__v_0];
-        record.function_queries[545].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        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_6: G = __loaded[0];
-        let __v_7: G = __loaded[1];
-        let __v_8: G = __loaded[2];
-        let __v_9: G = __loaded[3];
-        match __v_6.as_canonical_u64() {
-          5u64 => {
-            let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_5, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } else { aiur_fn_546(__args, record, io_buffer, __cu)? } };
-            let __v_10: G = __r_arr[0];
-            let __v_11: G = G::from_u64(0);
-            let __r_arr: [G; OUT_419] = { let __args: [G; IN_419] = [__v_8, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[419].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_419] = unsafe { *(result.output.as_ptr() as *const [G; OUT_419]) }; __ret } else { aiur_fn_419(__args, record, io_buffer, __cu)? } };
-            let __v_12: G = __r_arr[0];
-            let __v_13: G = G::from_u64(1);
-            let __v_14: G = (__v_1 - __v_13);
-            let __v_15: G = G::from_u64(1);
-            let __v_16: G = (__v_5 + __v_15);
-            let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_12, __v_14, __v_2, __v_3, __v_4, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[545].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_545] = unsafe { *(result.output.as_ptr() as *const [G; OUT_545]) }; __ret } else { aiur_fn_545(__args, record, io_buffer, __cu)? } };
-            let __v_17: G = __r_arr[0];
-            let __ret: [G; OUT_545] = [__v_17];
-            record.function_queries[545].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64()));
-          },
-        }
-      },
-    }
+    let __v_0: G = G::from_u64(180);
+    let __v_1: G = G::from_u64(178);
+    let __v_2: G = G::from_u64(108);
+    let __v_3: G = G::from_u64(46);
+    let __v_4: G = G::from_u64(41);
+    let __v_5: G = G::from_u64(147);
+    let __v_6: G = G::from_u64(28);
+    let __v_7: G = G::from_u64(6);
+    let __v_8: G = G::from_u64(232);
+    let __v_9: G = G::from_u64(133);
+    let __v_10: G = G::from_u64(145);
+    let __v_11: G = G::from_u64(70);
+    let __v_12: G = G::from_u64(19);
+    let __v_13: G = G::from_u64(250);
+    let __v_14: G = G::from_u64(255);
+    let __v_15: G = G::from_u64(88);
+    let __v_16: G = G::from_u64(86);
+    let __v_17: G = G::from_u64(19);
+    let __v_18: G = G::from_u64(142);
+    let __v_19: G = G::from_u64(92);
+    let __v_20: G = G::from_u64(176);
+    let __v_21: G = G::from_u64(150);
+    let __v_22: G = G::from_u64(32);
+    let __v_23: G = G::from_u64(221);
+    let __v_24: G = G::from_u64(182);
+    let __v_25: G = G::from_u64(146);
+    let __v_26: G = G::from_u64(26);
+    let __v_27: G = G::from_u64(52);
+    let __v_28: G = G::from_u64(45);
+    let __v_29: G = G::from_u64(237);
+    let __v_30: G = G::from_u64(137);
+    let __v_31: G = G::from_u64(87);
+    let __v_32: G = { let __values: [G; 32] = [__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]; 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_447] = [__v_32];
+    record.function_queries[447].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_546: usize = 4;
-const IN_546: usize = 4;
-const OUT_546: usize = 1;
-fn aiur_fn_546(
-  inp: [G; IN_546],
+const INPUT_SIZE_448: usize = 0;
+const IN_448: usize = 0;
+const OUT_448: usize = 1;
+fn aiur_fn_448(
+  inp: [G; IN_448],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_546], ExecError> {
+) -> Result<[G; OUT_448], 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(0);
-        let __v_5: G = G::from_u64(1);
-        let __v_6: G = (__v_1 - __v_5);
-        let __v_7: G = (__v_6 - __v_0);
-        let __v_8: G = G::from_u64(0);
-        let __v_9: G = { let __values: [G; 4] = [__v_4, __v_7, __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_546] = [__v_9];
-        record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { 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_4: G = __r_arr[0];
-        let __v_5: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_4.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() {
-          1u64 => {
-            let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_3, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-            let __v_6: G = __r_arr[0];
-            let __ret: [G; OUT_546] = [__v_6];
-            record.function_queries[546].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 = (__v_1 - __v_7);
-            let __v_9: G = (__v_8 - __v_0);
-            let __v_10: G = G::from_u64(0);
-            let __v_11: G = { let __values: [G; 4] = [__v_6, __v_9, __v_10, __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_546] = [__v_11];
-            record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-        }
-      },
-    }
+    let __v_0: G = G::from_u64(192);
+    let __v_1: G = G::from_u64(19);
+    let __v_2: G = G::from_u64(193);
+    let __v_3: G = G::from_u64(83);
+    let __v_4: G = G::from_u64(235);
+    let __v_5: G = G::from_u64(240);
+    let __v_6: G = G::from_u64(32);
+    let __v_7: G = G::from_u64(40);
+    let __v_8: G = G::from_u64(174);
+    let __v_9: G = G::from_u64(210);
+    let __v_10: G = G::from_u64(100);
+    let __v_11: G = G::from_u64(51);
+    let __v_12: G = G::from_u64(60);
+    let __v_13: G = G::from_u64(30);
+    let __v_14: G = G::from_u64(76);
+    let __v_15: G = G::from_u64(133);
+    let __v_16: G = G::from_u64(1);
+    let __v_17: G = G::from_u64(125);
+    let __v_18: G = G::from_u64(11);
+    let __v_19: G = G::from_u64(135);
+    let __v_20: G = G::from_u64(2);
+    let __v_21: G = G::from_u64(93);
+    let __v_22: G = G::from_u64(117);
+    let __v_23: G = G::from_u64(150);
+    let __v_24: G = G::from_u64(169);
+    let __v_25: G = G::from_u64(105);
+    let __v_26: G = G::from_u64(113);
+    let __v_27: G = G::from_u64(187);
+    let __v_28: G = G::from_u64(43);
+    let __v_29: G = G::from_u64(103);
+    let __v_30: G = G::from_u64(146);
+    let __v_31: G = G::from_u64(29);
+    let __v_32: G = { let __values: [G; 32] = [__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]; 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_448] = [__v_32];
+    record.function_queries[448].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_547: usize = 4;
-const IN_547: usize = 4;
-const OUT_547: usize = 1;
-fn aiur_fn_547(
-  inp: [G; IN_547],
+const INPUT_SIZE_449: usize = 0;
+const IN_449: usize = 0;
+const OUT_449: usize = 1;
+fn aiur_fn_449(
+  inp: [G; IN_449],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_547], ExecError> {
+) -> Result<[G; OUT_449], 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 __r_arr: [G; OUT_516] = { let __args: [G; IN_516] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[516].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_516] = unsafe { *(result.output.as_ptr() as *const [G; OUT_516]) }; __ret } else { aiur_fn_516(__args, record, io_buffer, __cu)? } };
-        let __v_4: G = __r_arr[0];
-        let __ret: [G; OUT_547] = [__v_4];
-        record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        let __v_4: G = G::from_u64(0);
-        let __v_5: G = G::from_u64(0);
-        let __v_6: G = G::from_u64(1);
-        let __v_7: G = G::from_u64(0);
-        let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_0, __v_1, __v_4, __v_5, __v_6, __v_3, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[549].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_549] = unsafe { *(result.output.as_ptr() as *const [G; OUT_549]) }; __ret } else { aiur_fn_549(__args, record, io_buffer, __cu)? } };
-        let __v_8: G = __r_arr[0];
-        let __ret: [G; OUT_547] = [__v_8];
-        record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-    }
+    let __v_0: G = G::from_u64(15);
+    let __v_1: G = G::from_u64(158);
+    let __v_2: G = G::from_u64(232);
+    let __v_3: G = G::from_u64(217);
+    let __v_4: G = G::from_u64(3);
+    let __v_5: G = G::from_u64(61);
+    let __v_6: G = G::from_u64(143);
+    let __v_7: G = G::from_u64(123);
+    let __v_8: G = G::from_u64(133);
+    let __v_9: G = G::from_u64(47);
+    let __v_10: G = G::from_u64(91);
+    let __v_11: G = G::from_u64(113);
+    let __v_12: G = G::from_u64(82);
+    let __v_13: G = G::from_u64(253);
+    let __v_14: G = G::from_u64(18);
+    let __v_15: G = G::from_u64(79);
+    let __v_16: G = G::from_u64(125);
+    let __v_17: G = G::from_u64(65);
+    let __v_18: G = G::from_u64(25);
+    let __v_19: G = G::from_u64(48);
+    let __v_20: G = G::from_u64(201);
+    let __v_21: G = G::from_u64(146);
+    let __v_22: G = G::from_u64(224);
+    let __v_23: G = G::from_u64(244);
+    let __v_24: G = G::from_u64(87);
+    let __v_25: G = G::from_u64(248);
+    let __v_26: G = G::from_u64(16);
+    let __v_27: G = G::from_u64(75);
+    let __v_28: G = G::from_u64(96);
+    let __v_29: G = G::from_u64(169);
+    let __v_30: G = G::from_u64(131);
+    let __v_31: G = G::from_u64(129);
+    let __v_32: G = { let __values: [G; 32] = [__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]; 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_449] = [__v_32];
+    record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_548: usize = 2;
-const IN_548: usize = 2;
-const OUT_548: usize = 1;
-fn aiur_fn_548(
-  inp: [G; IN_548],
+const INPUT_SIZE_450: usize = 0;
+const IN_450: usize = 0;
+const OUT_450: usize = 1;
+fn aiur_fn_450(
+  inp: [G; IN_450],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_548], ExecError> {
+) -> Result<[G; OUT_450], 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_778] = { let __args: [G; IN_778] = [__v_1, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-    let __v_2: G = __r_arr[0];
-    let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr };
-    let __v_3: G = __loaded[0];
-    let __v_4: G = __loaded[1];
-    let __v_5: G = __loaded[2];
-    let __v_6: G = __loaded[3];
-    let __v_7: G = __loaded[4];
-    let __v_8: G = __loaded[5];
-    let __v_9: G = __loaded[6];
-    let __v_10: G = __loaded[7];
-    let __v_11: G = __loaded[8];
-    let __v_12: G = __loaded[9];
-    let __v_13: G = __loaded[10];
-    match __v_3.as_canonical_u64() {
-      6u64 => {
-        let __ret: [G; OUT_548] = [__v_8];
-        record.function_queries[548].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        let __v_14: G = G::from_u64(0);
-        let __ret: [G; OUT_548] = [__v_14];
-        record.function_queries[548].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-    }
+    let __v_0: G = G::from_u64(4);
+    let __v_1: G = G::from_u64(113);
+    let __v_2: G = G::from_u64(228);
+    let __v_3: G = G::from_u64(113);
+    let __v_4: G = G::from_u64(88);
+    let __v_5: G = G::from_u64(178);
+    let __v_6: G = G::from_u64(174);
+    let __v_7: G = G::from_u64(24);
+    let __v_8: G = G::from_u64(211);
+    let __v_9: G = G::from_u64(192);
+    let __v_10: G = G::from_u64(141);
+    let __v_11: G = G::from_u64(213);
+    let __v_12: G = G::from_u64(199);
+    let __v_13: G = G::from_u64(122);
+    let __v_14: G = G::from_u64(174);
+    let __v_15: G = G::from_u64(35);
+    let __v_16: G = G::from_u64(230);
+    let __v_17: G = G::from_u64(45);
+    let __v_18: G = G::from_u64(123);
+    let __v_19: G = G::from_u64(188);
+    let __v_20: G = G::from_u64(30);
+    let __v_21: G = G::from_u64(97);
+    let __v_22: G = G::from_u64(17);
+    let __v_23: G = G::from_u64(107);
+    let __v_24: G = G::from_u64(194);
+    let __v_25: G = G::from_u64(129);
+    let __v_26: G = G::from_u64(59);
+    let __v_27: G = G::from_u64(19);
+    let __v_28: G = G::from_u64(6);
+    let __v_29: G = G::from_u64(188);
+    let __v_30: G = G::from_u64(87);
+    let __v_31: G = G::from_u64(149);
+    let __v_32: G = { let __values: [G; 32] = [__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]; 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_450] = [__v_32];
+    record.function_queries[450].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_451: usize = 0;
+const IN_451: usize = 0;
+const OUT_451: usize = 1;
+fn aiur_fn_451(
+  inp: [G; IN_451],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_451], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = G::from_u64(33);
+    let __v_1: G = G::from_u64(224);
+    let __v_2: G = G::from_u64(224);
+    let __v_3: G = G::from_u64(120);
+    let __v_4: G = G::from_u64(59);
+    let __v_5: G = G::from_u64(118);
+    let __v_6: G = G::from_u64(23);
+    let __v_7: G = G::from_u64(176);
+    let __v_8: G = G::from_u64(204);
+    let __v_9: G = G::from_u64(78);
+    let __v_10: G = G::from_u64(255);
+    let __v_11: G = G::from_u64(77);
+    let __v_12: G = G::from_u64(31);
+    let __v_13: G = G::from_u64(171);
+    let __v_14: G = G::from_u64(124);
+    let __v_15: G = G::from_u64(255);
+    let __v_16: G = G::from_u64(239);
+    let __v_17: G = G::from_u64(224);
+    let __v_18: G = G::from_u64(28);
+    let __v_19: G = G::from_u64(212);
+    let __v_20: G = G::from_u64(61);
+    let __v_21: G = G::from_u64(167);
+    let __v_22: G = G::from_u64(126);
+    let __v_23: G = G::from_u64(47);
+    let __v_24: G = G::from_u64(152);
+    let __v_25: G = G::from_u64(209);
+    let __v_26: G = G::from_u64(80);
+    let __v_27: G = G::from_u64(148);
+    let __v_28: G = G::from_u64(160);
+    let __v_29: G = G::from_u64(216);
+    let __v_30: G = G::from_u64(240);
+    let __v_31: G = G::from_u64(134);
+    let __v_32: G = { let __values: [G; 32] = [__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]; 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_451] = [__v_32];
+    record.function_queries[451].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_452: usize = 0;
+const IN_452: usize = 0;
+const OUT_452: usize = 1;
+fn aiur_fn_452(
+  inp: [G; IN_452],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_452], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = G::from_u64(1);
+    let __v_1: G = G::from_u64(131);
+    let __v_2: G = G::from_u64(89);
+    let __v_3: G = G::from_u64(91);
+    let __v_4: G = G::from_u64(131);
+    let __v_5: G = G::from_u64(123);
+    let __v_6: G = G::from_u64(155);
+    let __v_7: G = G::from_u64(132);
+    let __v_8: G = G::from_u64(218);
+    let __v_9: G = G::from_u64(95);
+    let __v_10: G = G::from_u64(0);
+    let __v_11: G = G::from_u64(75);
+    let __v_12: G = G::from_u64(138);
+    let __v_13: G = G::from_u64(196);
+    let __v_14: G = G::from_u64(164);
+    let __v_15: G = G::from_u64(187);
+    let __v_16: G = G::from_u64(211);
+    let __v_17: G = G::from_u64(188);
+    let __v_18: G = G::from_u64(6);
+    let __v_19: G = G::from_u64(40);
+    let __v_20: G = G::from_u64(185);
+    let __v_21: G = G::from_u64(156);
+    let __v_22: G = G::from_u64(141);
+    let __v_23: G = G::from_u64(85);
+    let __v_24: G = G::from_u64(14);
+    let __v_25: G = G::from_u64(179);
+    let __v_26: G = G::from_u64(81);
+    let __v_27: G = G::from_u64(247);
+    let __v_28: G = G::from_u64(76);
+    let __v_29: G = G::from_u64(225);
+    let __v_30: G = G::from_u64(109);
+    let __v_31: G = G::from_u64(72);
+    let __v_32: G = { let __values: [G; 32] = [__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]; 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_452] = [__v_32];
+    record.function_queries[452].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_453: usize = 0;
+const IN_453: usize = 0;
+const OUT_453: usize = 1;
+fn aiur_fn_453(
+  inp: [G; IN_453],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_453], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = G::from_u64(156);
+    let __v_1: G = G::from_u64(230);
+    let __v_2: G = G::from_u64(227);
+    let __v_3: G = G::from_u64(34);
+    let __v_4: G = G::from_u64(241);
+    let __v_5: G = G::from_u64(148);
+    let __v_6: G = G::from_u64(129);
+    let __v_7: G = G::from_u64(242);
+    let __v_8: G = G::from_u64(28);
+    let __v_9: G = G::from_u64(244);
+    let __v_10: G = G::from_u64(196);
+    let __v_11: G = G::from_u64(143);
+    let __v_12: G = G::from_u64(136);
+    let __v_13: G = G::from_u64(120);
+    let __v_14: G = G::from_u64(152);
+    let __v_15: G = G::from_u64(118);
+    let __v_16: G = G::from_u64(182);
+    let __v_17: G = G::from_u64(155);
+    let __v_18: G = G::from_u64(138);
+    let __v_19: G = G::from_u64(155);
+    let __v_20: G = G::from_u64(21);
+    let __v_21: G = G::from_u64(32);
+    let __v_22: G = G::from_u64(67);
+    let __v_23: G = G::from_u64(156);
+    let __v_24: G = G::from_u64(16);
+    let __v_25: G = G::from_u64(29);
+    let __v_26: G = G::from_u64(152);
+    let __v_27: G = G::from_u64(63);
+    let __v_28: G = G::from_u64(150);
+    let __v_29: G = G::from_u64(234);
+    let __v_30: G = G::from_u64(96);
+    let __v_31: G = G::from_u64(183);
+    let __v_32: G = { let __values: [G; 32] = [__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]; 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_453] = [__v_32];
+    record.function_queries[453].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_549: usize = 7;
-const IN_549: usize = 7;
-const OUT_549: usize = 1;
-fn aiur_fn_549(
-  inp: [G; IN_549],
+const INPUT_SIZE_454: usize = 0;
+const IN_454: usize = 0;
+const OUT_454: usize = 1;
+fn aiur_fn_454(
+  inp: [G; IN_454],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_549], ExecError> {
+) -> Result<[G; OUT_454], 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];
-    match __v_1.as_canonical_u64() {
-      0u64 => {
-        let __ret: [G; OUT_549] = [__v_0];
-        record.function_queries[549].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        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_7: G = __loaded[0];
-        let __v_8: G = __loaded[1];
-        let __v_9: G = __loaded[2];
-        let __v_10: G = __loaded[3];
-        match __v_7.as_canonical_u64() {
-          5u64 => {
-            let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_6, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[550].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_550] = unsafe { *(result.output.as_ptr() as *const [G; OUT_550]) }; __ret } else { aiur_fn_550(__args, record, io_buffer, __cu)? } };
-            let __v_11: G = __r_arr[0];
-            let __v_12: G = G::from_u64(0);
-            let __r_arr: [G; OUT_419] = { let __args: [G; IN_419] = [__v_9, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[419].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_419] = unsafe { *(result.output.as_ptr() as *const [G; OUT_419]) }; __ret } else { aiur_fn_419(__args, record, io_buffer, __cu)? } };
-            let __v_13: G = __r_arr[0];
-            let __v_14: G = G::from_u64(1);
-            let __v_15: G = (__v_1 - __v_14);
-            let __v_16: G = G::from_u64(1);
-            let __v_17: G = (__v_6 + __v_16);
-            let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_13, __v_15, __v_2, __v_3, __v_4, __v_5, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[549].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_549] = unsafe { *(result.output.as_ptr() as *const [G; OUT_549]) }; __ret } else { aiur_fn_549(__args, record, io_buffer, __cu)? } };
-            let __v_18: G = __r_arr[0];
-            let __ret: [G; OUT_549] = [__v_18];
-            record.function_queries[549].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64()));
-          },
-        }
-      },
-    }
+    let __v_0: G = G::from_u64(60);
+    let __v_1: G = G::from_u64(245);
+    let __v_2: G = G::from_u64(77);
+    let __v_3: G = G::from_u64(51);
+    let __v_4: G = G::from_u64(56);
+    let __v_5: G = G::from_u64(33);
+    let __v_6: G = G::from_u64(221);
+    let __v_7: G = G::from_u64(55);
+    let __v_8: G = G::from_u64(104);
+    let __v_9: G = G::from_u64(58);
+    let __v_10: G = G::from_u64(11);
+    let __v_11: G = G::from_u64(243);
+    let __v_12: G = G::from_u64(135);
+    let __v_13: G = G::from_u64(57);
+    let __v_14: G = G::from_u64(230);
+    let __v_15: G = G::from_u64(135);
+    let __v_16: G = G::from_u64(97);
+    let __v_17: G = G::from_u64(10);
+    let __v_18: G = G::from_u64(25);
+    let __v_19: G = G::from_u64(145);
+    let __v_20: G = G::from_u64(117);
+    let __v_21: G = G::from_u64(146);
+    let __v_22: G = G::from_u64(32);
+    let __v_23: G = G::from_u64(183);
+    let __v_24: G = G::from_u64(126);
+    let __v_25: G = G::from_u64(222);
+    let __v_26: G = G::from_u64(195);
+    let __v_27: G = G::from_u64(56);
+    let __v_28: G = G::from_u64(186);
+    let __v_29: G = G::from_u64(60);
+    let __v_30: G = G::from_u64(251);
+    let __v_31: G = G::from_u64(200);
+    let __v_32: G = { let __values: [G; 32] = [__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]; 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_454] = [__v_32];
+    record.function_queries[454].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_550: usize = 5;
-const IN_550: usize = 5;
-const OUT_550: usize = 1;
-fn aiur_fn_550(
-  inp: [G; IN_550],
+const INPUT_SIZE_455: usize = 0;
+const IN_455: usize = 0;
+const OUT_455: usize = 1;
+fn aiur_fn_455(
+  inp: [G; IN_455],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_550], ExecError> {
+) -> Result<[G; OUT_455], 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(0);
-        let __v_6: G = G::from_u64(1);
-        let __v_7: G = (__v_1 - __v_6);
-        let __v_8: G = (__v_7 - __v_0);
-        let __v_9: G = G::from_u64(0);
-        let __v_10: G = { let __values: [G; 4] = [__v_5, __v_8, __v_9, __v_9]; 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_550] = [__v_10];
-        record.function_queries[550].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { 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_5: G = __r_arr[0];
-        let __v_6: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_5.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_6.as_canonical_u64() {
-          1u64 => {
-            let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_4, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-            let __v_7: G = __r_arr[0];
-            let __v_8: G = G::from_u64(0);
-            let __r_arr: [G; OUT_413] = { let __args: [G; IN_413] = [__v_7, __v_2, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[413].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_413] = unsafe { *(result.output.as_ptr() as *const [G; OUT_413]) }; __ret } else { aiur_fn_413(__args, record, io_buffer, __cu)? } };
-            let __v_9: G = __r_arr[0];
-            let __ret: [G; OUT_550] = [__v_9];
-            record.function_queries[550].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            let __v_7: G = G::from_u64(0);
-            let __v_8: G = G::from_u64(1);
-            let __v_9: G = (__v_1 - __v_8);
-            let __v_10: G = (__v_9 - __v_0);
-            let __v_11: G = G::from_u64(0);
-            let __v_12: G = { let __values: [G; 4] = [__v_7, __v_10, __v_11, __v_11]; 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_550] = [__v_12];
-            record.function_queries[550].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-        }
-      },
-    }
+    let __v_0: G = G::from_u64(230);
+    let __v_1: G = G::from_u64(235);
+    let __v_2: G = G::from_u64(163);
+    let __v_3: G = G::from_u64(200);
+    let __v_4: G = G::from_u64(180);
+    let __v_5: G = G::from_u64(209);
+    let __v_6: G = G::from_u64(159);
+    let __v_7: G = G::from_u64(106);
+    let __v_8: G = G::from_u64(16);
+    let __v_9: G = G::from_u64(118);
+    let __v_10: G = G::from_u64(179);
+    let __v_11: G = G::from_u64(159);
+    let __v_12: G = G::from_u64(168);
+    let __v_13: G = G::from_u64(154);
+    let __v_14: G = G::from_u64(236);
+    let __v_15: G = G::from_u64(97);
+    let __v_16: G = G::from_u64(220);
+    let __v_17: G = G::from_u64(203);
+    let __v_18: G = G::from_u64(185);
+    let __v_19: G = G::from_u64(96);
+    let __v_20: G = G::from_u64(248);
+    let __v_21: G = G::from_u64(61);
+    let __v_22: G = G::from_u64(154);
+    let __v_23: G = G::from_u64(98);
+    let __v_24: G = G::from_u64(230);
+    let __v_25: G = G::from_u64(172);
+    let __v_26: G = G::from_u64(243);
+    let __v_27: G = G::from_u64(90);
+    let __v_28: G = G::from_u64(105);
+    let __v_29: G = G::from_u64(201);
+    let __v_30: G = G::from_u64(160);
+    let __v_31: G = G::from_u64(164);
+    let __v_32: G = { let __values: [G; 32] = [__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]; 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_455] = [__v_32];
+    record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_551: usize = 4;
-const IN_551: usize = 4;
-const OUT_551: usize = 1;
-fn aiur_fn_551(
-  inp: [G; IN_551],
+const INPUT_SIZE_456: usize = 0;
+const IN_456: usize = 0;
+const OUT_456: usize = 1;
+fn aiur_fn_456(
+  inp: [G; IN_456],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_551], ExecError> {
+) -> Result<[G; OUT_456], 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_1.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_551] = [__v_6];
-        record.function_queries[551].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        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_439] = { let __args: [G; IN_439] = [__v_0, __v_6, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } };
-        let __v_7: 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_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: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].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];
-        match __v_8.as_canonical_u64() {
-          5u64 => {
-            let __v_12: G = G::from_u64(0);
-            let __v_13: G = G::from_u64(1);
-            let __v_14: G = (__v_1 - __v_13);
-            let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_10, __v_14, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[551].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_551] = unsafe { *(result.output.as_ptr() as *const [G; OUT_551]) }; __ret } else { aiur_fn_551(__args, record, io_buffer, __cu)? } };
-            let __v_15: G = __r_arr[0];
-            let __v_16: G = { let __values: [G; 3] = [__v_12, __v_9, __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 __ret: [G; OUT_551] = [__v_16];
-            record.function_queries[551].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64()));
-          },
-        }
-      },
-    }
+    let __v_0: G = G::from_u64(108);
+    let __v_1: G = G::from_u64(155);
+    let __v_2: G = G::from_u64(214);
+    let __v_3: G = G::from_u64(14);
+    let __v_4: G = G::from_u64(30);
+    let __v_5: G = G::from_u64(174);
+    let __v_6: G = G::from_u64(147);
+    let __v_7: G = G::from_u64(142);
+    let __v_8: G = G::from_u64(86);
+    let __v_9: G = G::from_u64(38);
+    let __v_10: G = G::from_u64(202);
+    let __v_11: G = G::from_u64(35);
+    let __v_12: G = G::from_u64(125);
+    let __v_13: G = G::from_u64(188);
+    let __v_14: G = G::from_u64(167);
+    let __v_15: G = G::from_u64(253);
+    let __v_16: G = G::from_u64(149);
+    let __v_17: G = G::from_u64(15);
+    let __v_18: G = G::from_u64(46);
+    let __v_19: G = G::from_u64(153);
+    let __v_20: G = G::from_u64(226);
+    let __v_21: G = G::from_u64(52);
+    let __v_22: G = G::from_u64(169);
+    let __v_23: G = G::from_u64(156);
+    let __v_24: G = G::from_u64(35);
+    let __v_25: G = G::from_u64(207);
+    let __v_26: G = G::from_u64(220);
+    let __v_27: G = G::from_u64(41);
+    let __v_28: G = G::from_u64(76);
+    let __v_29: G = G::from_u64(167);
+    let __v_30: G = G::from_u64(173);
+    let __v_31: G = G::from_u64(206);
+    let __v_32: G = { let __values: [G; 32] = [__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]; 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_456] = [__v_32];
+    record.function_queries[456].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_552: usize = 3;
-const IN_552: usize = 3;
-const OUT_552: usize = 1;
-fn aiur_fn_552(
-  inp: [G; IN_552],
+const INPUT_SIZE_457: usize = 0;
+const IN_457: usize = 0;
+const OUT_457: usize = 1;
+fn aiur_fn_457(
+  inp: [G; IN_457],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_552], ExecError> {
+) -> Result<[G; OUT_457], 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 = (__v_1 - __v_2);
-    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; 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_552] = [__v_6];
-        record.function_queries[552].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        let __v_4: G = G::from_u64(0);
-        let __v_5: G = G::from_u64(4);
-        let __v_6: G = (__v_0 + __v_2);
-        let __v_7: G = G::from_u64(0);
-        let __v_8: G = { let __values: [G; 3] = [__v_5, __v_6, __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 __v_9: G = G::from_u64(1);
-        let __v_10: G = (__v_2 + __v_9);
-        let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_0, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[552].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_552] = unsafe { *(result.output.as_ptr() as *const [G; OUT_552]) }; __ret } else { aiur_fn_552(__args, record, io_buffer, __cu)? } };
-        let __v_11: G = __r_arr[0];
-        let __v_12: G = { let __values: [G; 3] = [__v_4, __v_8, __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_552] = [__v_12];
-        record.function_queries[552].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-    }
+    let __v_0: G = G::from_u64(131);
+    let __v_1: G = G::from_u64(253);
+    let __v_2: G = G::from_u64(227);
+    let __v_3: G = G::from_u64(143);
+    let __v_4: G = G::from_u64(170);
+    let __v_5: G = G::from_u64(17);
+    let __v_6: G = G::from_u64(100);
+    let __v_7: G = G::from_u64(100);
+    let __v_8: G = G::from_u64(142);
+    let __v_9: G = G::from_u64(66);
+    let __v_10: G = G::from_u64(39);
+    let __v_11: G = G::from_u64(151);
+    let __v_12: G = G::from_u64(90);
+    let __v_13: G = G::from_u64(191);
+    let __v_14: G = G::from_u64(46);
+    let __v_15: G = G::from_u64(140);
+    let __v_16: G = G::from_u64(38);
+    let __v_17: G = G::from_u64(13);
+    let __v_18: G = G::from_u64(125);
+    let __v_19: G = G::from_u64(78);
+    let __v_20: G = G::from_u64(241);
+    let __v_21: G = G::from_u64(201);
+    let __v_22: G = G::from_u64(38);
+    let __v_23: G = G::from_u64(118);
+    let __v_24: G = G::from_u64(33);
+    let __v_25: G = G::from_u64(79);
+    let __v_26: G = G::from_u64(254);
+    let __v_27: G = G::from_u64(88);
+    let __v_28: G = G::from_u64(38);
+    let __v_29: G = G::from_u64(194);
+    let __v_30: G = G::from_u64(7);
+    let __v_31: G = G::from_u64(93);
+    let __v_32: G = { let __values: [G; 32] = [__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]; 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_457] = [__v_32];
+    record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_553: usize = 4;
-const IN_553: usize = 4;
-const OUT_553: usize = 1;
-fn aiur_fn_553(
-  inp: [G; IN_553],
+const INPUT_SIZE_458: usize = 0;
+const IN_458: usize = 0;
+const OUT_458: usize = 1;
+fn aiur_fn_458(
+  inp: [G; IN_458],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_553], ExecError> {
+) -> Result<[G; OUT_458], 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_1 - __v_3);
-    match __v_4.as_canonical_u64() {
-      0u64 => {
-        let __ret: [G; OUT_553] = [__v_0];
-        record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        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 __v_8: G = (__v_7 - __v_3);
-        let __v_9: G = (__v_8 + __v_2);
-        let __v_10: G = G::from_u64(0);
-        let __v_11: G = { let __values: [G; 4] = [__v_5, __v_9, __v_10, __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 __v_12: G = G::from_u64(3);
-        let __v_13: G = G::from_u64(0);
-        let __v_14: G = { let __values: [G; 4] = [__v_12, __v_0, __v_11, __v_13]; 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_15: G = G::from_u64(1);
-        let __v_16: G = (__v_3 + __v_15);
-        let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_14, __v_1, __v_2, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[553].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_553] = unsafe { *(result.output.as_ptr() as *const [G; OUT_553]) }; __ret } else { aiur_fn_553(__args, record, io_buffer, __cu)? } };
-        let __v_17: G = __r_arr[0];
-        let __ret: [G; OUT_553] = [__v_17];
-        record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-    }
+    let __v_0: G = G::from_u64(56);
+    let __v_1: G = G::from_u64(214);
+    let __v_2: G = G::from_u64(15);
+    let __v_3: G = G::from_u64(250);
+    let __v_4: G = G::from_u64(7);
+    let __v_5: G = G::from_u64(181);
+    let __v_6: G = G::from_u64(6);
+    let __v_7: G = G::from_u64(120);
+    let __v_8: G = G::from_u64(208);
+    let __v_9: G = G::from_u64(195);
+    let __v_10: G = G::from_u64(191);
+    let __v_11: G = G::from_u64(12);
+    let __v_12: G = G::from_u64(6);
+    let __v_13: G = G::from_u64(248);
+    let __v_14: G = G::from_u64(108);
+    let __v_15: G = G::from_u64(215);
+    let __v_16: G = G::from_u64(150);
+    let __v_17: G = G::from_u64(123);
+    let __v_18: G = G::from_u64(53);
+    let __v_19: G = G::from_u64(232);
+    let __v_20: G = G::from_u64(122);
+    let __v_21: G = G::from_u64(176);
+    let __v_22: G = G::from_u64(113);
+    let __v_23: G = G::from_u64(188);
+    let __v_24: G = G::from_u64(85);
+    let __v_25: G = G::from_u64(137);
+    let __v_26: G = G::from_u64(159);
+    let __v_27: G = G::from_u64(203);
+    let __v_28: G = G::from_u64(174);
+    let __v_29: G = G::from_u64(212);
+    let __v_30: G = G::from_u64(116);
+    let __v_31: G = G::from_u64(79);
+    let __v_32: G = { let __values: [G; 32] = [__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]; 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_458] = [__v_32];
+    record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_554: usize = 3;
-const IN_554: usize = 3;
-const OUT_554: usize = 1;
-fn aiur_fn_554(
-  inp: [G; IN_554],
+const INPUT_SIZE_459: usize = 0;
+const IN_459: usize = 0;
+const OUT_459: usize = 1;
+fn aiur_fn_459(
+  inp: [G; IN_459],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_554], ExecError> {
+) -> Result<[G; OUT_459], 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 = (__v_1 - __v_2);
-    match __v_3.as_canonical_u64() {
-      0u64 => {
-        let __ret: [G; OUT_554] = [__v_0];
-        record.function_queries[554].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        let __v_4: G = G::from_u64(0);
-        let __v_5: G = G::from_u64(1);
-        let __v_6: G = (__v_1 - __v_5);
-        let __v_7: G = (__v_6 - __v_2);
-        let __v_8: G = G::from_u64(0);
-        let __v_9: G = { let __values: [G; 4] = [__v_4, __v_7, __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 __v_10: G = G::from_u64(3);
-        let __v_11: G = G::from_u64(0);
-        let __v_12: G = { let __values: [G; 4] = [__v_10, __v_0, __v_9, __v_11]; 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_13: G = G::from_u64(1);
-        let __v_14: G = (__v_2 + __v_13);
-        let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_12, __v_1, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[554].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_554] = unsafe { *(result.output.as_ptr() as *const [G; OUT_554]) }; __ret } else { aiur_fn_554(__args, record, io_buffer, __cu)? } };
-        let __v_15: G = __r_arr[0];
-        let __ret: [G; OUT_554] = [__v_15];
-        record.function_queries[554].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-    }
+    let __v_0: G = G::from_u64(85);
+    let __v_1: G = G::from_u64(104);
+    let __v_2: G = G::from_u64(231);
+    let __v_3: G = G::from_u64(153);
+    let __v_4: G = G::from_u64(25);
+    let __v_5: G = G::from_u64(141);
+    let __v_6: G = G::from_u64(173);
+    let __v_7: G = G::from_u64(159);
+    let __v_8: G = G::from_u64(171);
+    let __v_9: G = G::from_u64(14);
+    let __v_10: G = G::from_u64(120);
+    let __v_11: G = G::from_u64(75);
+    let __v_12: G = G::from_u64(122);
+    let __v_13: G = G::from_u64(76);
+    let __v_14: G = G::from_u64(88);
+    let __v_15: G = G::from_u64(17);
+    let __v_16: G = G::from_u64(43);
+    let __v_17: G = G::from_u64(252);
+    let __v_18: G = G::from_u64(38);
+    let __v_19: G = G::from_u64(136);
+    let __v_20: G = G::from_u64(174);
+    let __v_21: G = G::from_u64(206);
+    let __v_22: G = G::from_u64(190);
+    let __v_23: G = G::from_u64(60);
+    let __v_24: G = G::from_u64(44);
+    let __v_25: G = G::from_u64(101);
+    let __v_26: G = G::from_u64(99);
+    let __v_27: G = G::from_u64(48);
+    let __v_28: G = G::from_u64(66);
+    let __v_29: G = G::from_u64(16);
+    let __v_30: G = G::from_u64(249);
+    let __v_31: G = G::from_u64(86);
+    let __v_32: G = { let __values: [G; 32] = [__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]; 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_459] = [__v_32];
+    record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_555: usize = 2;
-const IN_555: usize = 2;
-const OUT_555: usize = 1;
-fn aiur_fn_555(
-  inp: [G; IN_555],
+const INPUT_SIZE_460: usize = 0;
+const IN_460: usize = 0;
+const OUT_460: usize = 1;
+fn aiur_fn_460(
+  inp: [G; IN_460],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_555], 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_555] = [__v_0];
-        record.function_queries[555].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __v_5: G = G::from_u64(5);
-        let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[555].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_555] = unsafe { *(result.output.as_ptr() as *const [G; OUT_555]) }; __ret } else { aiur_fn_555(__args, record, io_buffer, __cu)? } };
-        let __v_6: G = __r_arr[0];
-        let __v_7: G = G::from_u64(0);
-        let __v_8: G = { let __values: [G; 4] = [__v_5, __v_3, __v_6, __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_555] = [__v_8];
-        record.function_queries[555].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
-    }
+) -> Result<[G; OUT_460], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = G::from_u64(9);
+    let __v_1: G = G::from_u64(188);
+    let __v_2: G = G::from_u64(37);
+    let __v_3: G = G::from_u64(49);
+    let __v_4: G = G::from_u64(71);
+    let __v_5: G = G::from_u64(195);
+    let __v_6: G = G::from_u64(108);
+    let __v_7: G = G::from_u64(226);
+    let __v_8: G = G::from_u64(44);
+    let __v_9: G = G::from_u64(142);
+    let __v_10: G = G::from_u64(12);
+    let __v_11: G = G::from_u64(205);
+    let __v_12: G = G::from_u64(67);
+    let __v_13: G = G::from_u64(199);
+    let __v_14: G = G::from_u64(155);
+    let __v_15: G = G::from_u64(44);
+    let __v_16: G = G::from_u64(218);
+    let __v_17: G = G::from_u64(226);
+    let __v_18: G = G::from_u64(32);
+    let __v_19: G = G::from_u64(110);
+    let __v_20: G = G::from_u64(13);
+    let __v_21: G = G::from_u64(221);
+    let __v_22: G = G::from_u64(22);
+    let __v_23: G = G::from_u64(143);
+    let __v_24: G = G::from_u64(202);
+    let __v_25: G = G::from_u64(54);
+    let __v_26: G = G::from_u64(9);
+    let __v_27: G = G::from_u64(178);
+    let __v_28: G = G::from_u64(165);
+    let __v_29: G = G::from_u64(132);
+    let __v_30: G = G::from_u64(211);
+    let __v_31: G = G::from_u64(220);
+    let __v_32: G = { let __values: [G; 32] = [__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]; 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_460] = [__v_32];
+    record.function_queries[460].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_556: usize = 16;
-const IN_556: usize = 16;
-const OUT_556: usize = 1;
-fn aiur_fn_556(
-  inp: [G; IN_556],
+const INPUT_SIZE_461: usize = 0;
+const IN_461: usize = 0;
+const OUT_461: usize = 1;
+fn aiur_fn_461(
+  inp: [G; IN_461],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_556], ExecError> {
+) -> Result<[G; OUT_461], 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 __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } };
-    let __v_16: G = __r_arr[0];
-    let __v_17: G = (__v_10 + __v_11);
-    let __v_18: G = (__v_9 + __v_17);
-    let __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = [__v_1, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[548].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_548] = unsafe { *(result.output.as_ptr() as *const [G; OUT_548]) }; __ret } else { aiur_fn_548(__args, record, io_buffer, __cu)? } };
-    let __v_19: G = __r_arr[0];
-    let __v_20: G = (__v_10 + __v_11);
-    let __v_21: G = G::from_u64(0);
-    let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_16, __v_19, __v_18, __v_20, __v_3, __v_4, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[549].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_549] = unsafe { *(result.output.as_ptr() as *const [G; OUT_549]) }; __ret } else { aiur_fn_549(__args, record, io_buffer, __cu)? } };
-    let __v_22: G = __r_arr[0];
-    let __v_23: G = G::from_u64(1);
-    let __v_24: G = G::from_u64(1);
-    let __v_25: G = { let __values: [G; 3] = [__v_23, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_26: G = G::from_u64(1);
-    let __v_27: G = G::from_u64(1);
-    let __v_28: G = { let __values: [G; 3] = [__v_26, __v_27, __v_27]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_29: G = G::from_u64(1);
-    let __v_30: G = G::from_u64(1);
-    let __v_31: G = { let __values: [G; 3] = [__v_29, __v_30, __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 = 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 __v_35: G = G::from_u64(0);
-    let __r_arr: [G; OUT_558] = { let __args: [G; IN_558] = [__v_22, __v_6, __v_25, __v_28, __v_31, __v_34, __v_14, __v_15, __v_35, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[558].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_558] = unsafe { *(result.output.as_ptr() as *const [G; OUT_558]) }; __ret } else { aiur_fn_558(__args, record, io_buffer, __cu)? } };
-    let __v_36: G = __r_arr[0];
-    let __v_37: G = __r_arr[1];
-    let __v_38: G = __r_arr[2];
-    let __v_39: G = __r_arr[3];
-    let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { 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_40: G = __r_arr[0];
-    let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { 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_41: G = __r_arr[0];
-    let __v_42: G = (__v_40 + __v_41);
-    let __v_43: G = (__v_18 + __v_42);
-    let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[189].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_189] = unsafe { *(result.output.as_ptr() as *const [G; OUT_189]) }; __ret } else { aiur_fn_189(__args, record, io_buffer, __cu)? } };
-    let __v_44: G = __r_arr[0];
-    let __v_45: G = __r_arr[1];
-    let __r_arr: [G; OUT_796] = { let __args: [G; IN_796] = [__v_45, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[796].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_796] = unsafe { *(result.output.as_ptr() as *const [G; OUT_796]) }; __ret } else { aiur_fn_796(__args, record, io_buffer, __cu)? } };
-    let __v_46: G = __r_arr[0];
-    let __v_47: G = G::from_u64(0);
-    let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_46, __v_41, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[570].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_570] = unsafe { *(result.output.as_ptr() as *const [G; OUT_570]) }; __ret } else { aiur_fn_570(__args, record, io_buffer, __cu)? } };
-    let __v_48: G = __r_arr[0];
-    let __v_49: G = G::from_u64(1);
-    let __v_50: G = (__v_43 - __v_49);
-    let __v_51: G = (__v_12 + __v_13);
-    let __v_52: G = (__v_50 - __v_51);
-    let __v_53: G = G::from_u64(0);
-    let __v_54: G = G::from_u64(0);
-    let __v_55: G = { let __values: [G; 4] = [__v_53, __v_52, __v_54, __v_54]; 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_427] = { let __args: [G; IN_427] = [__v_55, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[427].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_427] = unsafe { *(result.output.as_ptr() as *const [G; OUT_427]) }; __ret } else { aiur_fn_427(__args, record, io_buffer, __cu)? } };
-    let __v_56: G = __r_arr[0];
-    let __v_57: G = G::from_u64(2);
-    let __v_58: G = G::from_u64(0);
-    let __v_59: G = { let __values: [G; 4] = [__v_57, __v_1, __v_5, __v_58]; 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_557] = { let __args: [G; IN_557] = [__v_59, __v_19, __v_9, __v_43, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[557].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_557] = unsafe { *(result.output.as_ptr() as *const [G; OUT_557]) }; __ret } else { aiur_fn_557(__args, record, io_buffer, __cu)? } };
-    let __v_60: G = __r_arr[0];
-    let __v_61: G = G::from_u64(0);
-    let __r_arr: [G; OUT_572] = { let __args: [G; IN_572] = [__v_60, __v_40, __v_42, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[572].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_572] = unsafe { *(result.output.as_ptr() as *const [G; OUT_572]) }; __ret } else { aiur_fn_572(__args, record, io_buffer, __cu)? } };
-    let __v_62: G = __r_arr[0];
-    let __v_63: G = G::from_u64(3);
-    let __v_64: G = G::from_u64(0);
-    let __v_65: G = { let __values: [G; 4] = [__v_63, __v_56, __v_62, __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 __v_66: G = G::from_u64(1);
-    let __v_67: G = G::from_u64(1);
-    let __v_68: G = { let __values: [G; 3] = [__v_66, __v_67, __v_67]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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 = G::from_u64(0);
-    let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_37, __v_38, __v_36, __v_8, __v_12, __v_40, __v_18, __v_68, __v_14, __v_15, __v_69]; let __cu = unconstrained; if let Some(result) = record.function_queries[649].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_649] = unsafe { *(result.output.as_ptr() as *const [G; OUT_649]) }; __ret } else { aiur_fn_649(__args, record, io_buffer, __cu)? } };
-    let __v_70: G = __r_arr[0];
-    let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_65, __v_70]; let __cu = unconstrained; if let Some(result) = record.function_queries[555].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_555] = unsafe { *(result.output.as_ptr() as *const [G; OUT_555]) }; __ret } else { aiur_fn_555(__args, record, io_buffer, __cu)? } };
-    let __v_71: G = __r_arr[0];
-    let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_71, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[555].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_555] = unsafe { *(result.output.as_ptr() as *const [G; OUT_555]) }; __ret } else { aiur_fn_555(__args, record, io_buffer, __cu)? } };
-    let __v_72: G = __r_arr[0];
-    let __ret: [G; OUT_556] = [__v_72];
-    record.function_queries[556].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __v_0: G = G::from_u64(38);
+    let __v_1: G = G::from_u64(124);
+    let __v_2: G = G::from_u64(10);
+    let __v_3: G = G::from_u64(156);
+    let __v_4: G = G::from_u64(146);
+    let __v_5: G = G::from_u64(231);
+    let __v_6: G = G::from_u64(86);
+    let __v_7: G = G::from_u64(56);
+    let __v_8: G = G::from_u64(252);
+    let __v_9: G = G::from_u64(115);
+    let __v_10: G = G::from_u64(237);
+    let __v_11: G = G::from_u64(82);
+    let __v_12: G = G::from_u64(169);
+    let __v_13: G = G::from_u64(249);
+    let __v_14: G = G::from_u64(200);
+    let __v_15: G = G::from_u64(22);
+    let __v_16: G = G::from_u64(71);
+    let __v_17: G = G::from_u64(238);
+    let __v_18: G = G::from_u64(236);
+    let __v_19: G = G::from_u64(238);
+    let __v_20: G = G::from_u64(255);
+    let __v_21: G = G::from_u64(33);
+    let __v_22: G = G::from_u64(68);
+    let __v_23: G = G::from_u64(193);
+    let __v_24: G = G::from_u64(249);
+    let __v_25: G = G::from_u64(126);
+    let __v_26: G = G::from_u64(101);
+    let __v_27: G = G::from_u64(226);
+    let __v_28: G = G::from_u64(175);
+    let __v_29: G = G::from_u64(241);
+    let __v_30: G = G::from_u64(73);
+    let __v_31: G = G::from_u64(241);
+    let __v_32: G = { let __values: [G; 32] = [__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]; 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_461] = [__v_32];
+    record.function_queries[461].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_557: usize = 6;
-const IN_557: usize = 6;
-const OUT_557: usize = 1;
-fn aiur_fn_557(
-  inp: [G; IN_557],
+const INPUT_SIZE_462: usize = 1;
+const IN_462: usize = 1;
+const OUT_462: usize = 1;
+fn aiur_fn_462(
+  inp: [G; IN_462],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_557], ExecError> {
+) -> Result<[G; OUT_462], 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];
-    match __v_4.as_canonical_u64() {
-      0u64 => {
-        let __v_6: G = G::from_u64(1);
-        let __v_7: G = (__v_3 - __v_6);
-        let __v_8: G = G::from_u64(0);
-        let __r_arr: [G; OUT_571] = { let __args: [G; IN_571] = [__v_0, __v_2, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[571].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_571] = unsafe { *(result.output.as_ptr() as *const [G; OUT_571]) }; __ret } else { aiur_fn_571(__args, record, io_buffer, __cu)? } };
-        let __v_9: G = __r_arr[0];
-        let __ret: [G; OUT_557] = [__v_9];
-        record.function_queries[557].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[446].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_446] = unsafe { *(result.output.as_ptr() as *const [G; OUT_446]) }; __ret } else { aiur_fn_446(__args, record, io_buffer, __cu)? } };
+    let __v_1: G = __r_arr[0];
+    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_2: G = __r_arr[0];
+    match __v_2.as_canonical_u64() {
+      1u64 => {
+        let __v_3: G = G::from_u64(1);
+        let __ret: [G; OUT_462] = [__v_3];
+        record.function_queries[462].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __v_6: G = (__v_3 - __v_2);
-        let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_0, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[544].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_544] = unsafe { *(result.output.as_ptr() as *const [G; OUT_544]) }; __ret } else { aiur_fn_544(__args, record, io_buffer, __cu)? } };
-        let __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_557] = [__v_7];
-        record.function_queries[557].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
+        let __r_arr: [G; OUT_447] = { let __args: [G; IN_447] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[447].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_447] = unsafe { *(result.output.as_ptr() as *const [G; OUT_447]) }; __ret } else { aiur_fn_447(__args, record, io_buffer, __cu)? } };
+        let __v_3: G = __r_arr[0];
+        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_4: G = __r_arr[0];
+        match __v_4.as_canonical_u64() {
+          1u64 => {
+            let __v_5: G = G::from_u64(1);
+            let __ret: [G; OUT_462] = [__v_5];
+            record.function_queries[462].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            let __r_arr: [G; OUT_448] = { let __args: [G; IN_448] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[448].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_448] = unsafe { *(result.output.as_ptr() as *const [G; OUT_448]) }; __ret } else { aiur_fn_448(__args, record, io_buffer, __cu)? } };
+            let __v_5: G = __r_arr[0];
+            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_6: G = __r_arr[0];
+            match __v_6.as_canonical_u64() {
+              1u64 => {
+                let __v_7: G = G::from_u64(1);
+                let __ret: [G; OUT_462] = [__v_7];
+                record.function_queries[462].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[458].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_458] = unsafe { *(result.output.as_ptr() as *const [G; OUT_458]) }; __ret } else { aiur_fn_458(__args, record, io_buffer, __cu)? } };
+                let __v_7: G = __r_arr[0];
+                let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_8: G = __r_arr[0];
+                match __v_8.as_canonical_u64() {
+                  1u64 => {
+                    let __v_9: G = G::from_u64(1);
+                    let __ret: [G; OUT_462] = [__v_9];
+                    record.function_queries[462].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
+                  },
+                  _ => {
+                    let __r_arr: [G; OUT_457] = { let __args: [G; IN_457] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[457].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_457] = unsafe { *(result.output.as_ptr() as *const [G; OUT_457]) }; __ret } else { aiur_fn_457(__args, record, io_buffer, __cu)? } };
+                    let __v_9: G = __r_arr[0];
+                    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_10: G = __r_arr[0];
+                    match __v_10.as_canonical_u64() {
+                      1u64 => {
+                        let __v_11: G = G::from_u64(1);
+                        let __ret: [G; OUT_462] = [__v_11];
+                        record.function_queries[462].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        return Ok(__ret);
+                      },
+                      _ => {
+                        let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[459].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_459] = unsafe { *(result.output.as_ptr() as *const [G; OUT_459]) }; __ret } else { aiur_fn_459(__args, record, io_buffer, __cu)? } };
+                        let __v_11: G = __r_arr[0];
+                        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_12: G = __r_arr[0];
+                        match __v_12.as_canonical_u64() {
+                          1u64 => {
+                            let __v_13: G = G::from_u64(1);
+                            let __ret: [G; OUT_462] = [__v_13];
+                            record.function_queries[462].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            return Ok(__ret);
+                          },
+                          _ => {
+                            let __v_13: G = G::from_u64(0);
+                            let __ret: [G; OUT_462] = [__v_13];
+                            record.function_queries[462].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            return Ok(__ret);
+                          },
+                        }
+                      },
+                    }
+                  },
+                }
+              },
+            }
+          },
+        }
       },
     }
   })
 }
 
-const INPUT_SIZE_558: usize = 10;
-const IN_558: usize = 10;
-const OUT_558: usize = 4;
-fn aiur_fn_558(
-  inp: [G; IN_558],
+const INPUT_SIZE_463: usize = 1;
+const IN_463: usize = 1;
+const OUT_463: usize = 1;
+fn aiur_fn_463(
+  inp: [G; IN_463],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_558], ExecError> {
+) -> Result<[G; OUT_463], 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 __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_10: G = __loaded[0];
-    let __v_11: G = __loaded[1];
-    let __v_12: G = __loaded[2];
-    let __v_13: G = __loaded[3];
-    match __v_10.as_canonical_u64() {
-      5u64 => {
-        let __r_arr: [G; OUT_564] = { let __args: [G; IN_564] = [__v_11, __v_1, __v_5, __v_6, __v_7, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[564].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_564] = unsafe { *(result.output.as_ptr() as *const [G; OUT_564]) }; __ret } else { aiur_fn_564(__args, record, io_buffer, __cu)? } };
-        let __v_14: G = __r_arr[0];
-        let __v_15: G = __r_arr[1];
-        let __v_16: G = G::from_u64(0);
-        let __v_17: G = { let __values: [G; 3] = [__v_16, __v_11, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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 = G::from_u64(0);
-        let __v_19: G = { let __values: [G; 3] = [__v_18, __v_11, __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 } };
-        match __v_14.as_canonical_u64() {
+    let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[458].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_458] = unsafe { *(result.output.as_ptr() as *const [G; OUT_458]) }; __ret } else { aiur_fn_458(__args, record, io_buffer, __cu)? } };
+    let __v_1: G = __r_arr[0];
+    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_2: G = __r_arr[0];
+    match __v_2.as_canonical_u64() {
+      1u64 => {
+        let __v_3: G = G::from_u64(1);
+        let __ret: [G; OUT_463] = [__v_3];
+        record.function_queries[463].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_457] = { let __args: [G; IN_457] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[457].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_457] = unsafe { *(result.output.as_ptr() as *const [G; OUT_457]) }; __ret } else { aiur_fn_457(__args, record, io_buffer, __cu)? } };
+        let __v_3: G = __r_arr[0];
+        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_4: G = __r_arr[0];
+        match __v_4.as_canonical_u64() {
           1u64 => {
-            let __v_20: G = G::from_u64(0);
-            let __v_21: G = { let __values: [G; 3] = [__v_20, __v_8, __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 __v_22: G = G::from_u64(0);
-            let __v_23: G = { let __values: [G; 3] = [__v_22, __v_15, __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_24: G = G::from_u64(1);
-            let __v_25: G = (__v_8 + __v_24);
-            let __r_arr: [G; OUT_558] = { let __args: [G; IN_558] = [__v_12, __v_1, __v_17, __v_21, __v_23, __v_19, __v_6, __v_7, __v_25, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[558].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_558] = unsafe { *(result.output.as_ptr() as *const [G; OUT_558]) }; __ret } else { aiur_fn_558(__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 __ret: [G; OUT_558] = [__v_26, __v_27, __v_28, __v_29];
-            record.function_queries[558].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __v_5: G = G::from_u64(1);
+            let __ret: [G; OUT_463] = [__v_5];
+            record.function_queries[463].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __v_20: G = G::from_u64(1);
-            let __v_21: G = (__v_8 + __v_20);
-            let __r_arr: [G; OUT_558] = { let __args: [G; IN_558] = [__v_12, __v_1, __v_17, __v_3, __v_4, __v_19, __v_6, __v_7, __v_21, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[558].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_558] = unsafe { *(result.output.as_ptr() as *const [G; OUT_558]) }; __ret } else { aiur_fn_558(__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 __ret: [G; OUT_558] = [__v_22, __v_23, __v_24, __v_25];
-            record.function_queries[558].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
+            let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[459].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_459] = unsafe { *(result.output.as_ptr() as *const [G; OUT_459]) }; __ret } else { aiur_fn_459(__args, record, io_buffer, __cu)? } };
+            let __v_5: G = __r_arr[0];
+            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_6: G = __r_arr[0];
+            match __v_6.as_canonical_u64() {
+              1u64 => {
+                let __v_7: G = G::from_u64(1);
+                let __ret: [G; OUT_463] = [__v_7];
+                record.function_queries[463].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                let __v_7: G = G::from_u64(0);
+                let __ret: [G; OUT_463] = [__v_7];
+                record.function_queries[463].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+            }
           },
         }
       },
-      _ => {
-        let __r_arr: [G; OUT_776] = { let __args: [G; IN_776] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[776].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_776] = unsafe { *(result.output.as_ptr() as *const [G; OUT_776]) }; __ret } else { aiur_fn_776(__args, record, io_buffer, __cu)? } };
-        let __v_14: G = __r_arr[0];
-        let __r_arr: [G; OUT_776] = { let __args: [G; IN_776] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[776].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_776] = unsafe { *(result.output.as_ptr() as *const [G; OUT_776]) }; __ret } else { aiur_fn_776(__args, record, io_buffer, __cu)? } };
-        let __v_15: G = __r_arr[0];
-        let __r_arr: [G; OUT_776] = { let __args: [G; IN_776] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[776].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_776] = unsafe { *(result.output.as_ptr() as *const [G; OUT_776]) }; __ret } else { aiur_fn_776(__args, record, io_buffer, __cu)? } };
-        let __v_16: G = __r_arr[0];
-        let __ret: [G; OUT_558] = [__v_14, __v_15, __v_16, __v_0];
-        record.function_queries[558].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
     }
   })
 }
 
-const INPUT_SIZE_559: usize = 2;
-const IN_559: usize = 2;
-const OUT_559: usize = 1;
-fn aiur_fn_559(
-  inp: [G; IN_559],
+const INPUT_SIZE_464: usize = 1;
+const IN_464: usize = 1;
+const OUT_464: usize = 3;
+fn aiur_fn_464(
+  inp: [G; IN_464],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_559], ExecError> {
+) -> Result<[G; OUT_464], 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_778] = { let __args: [G; IN_778] = [__v_1, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-    let __v_2: G = __r_arr[0];
-    let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr };
-    let __v_3: G = __loaded[0];
-    let __v_4: G = __loaded[1];
-    let __v_5: G = __loaded[2];
-    let __v_6: G = __loaded[3];
-    let __v_7: G = __loaded[4];
-    let __v_8: G = __loaded[5];
-    let __v_9: G = __loaded[6];
-    let __v_10: G = __loaded[7];
-    let __v_11: G = __loaded[8];
-    let __v_12: G = __loaded[9];
-    let __v_13: G = __loaded[10];
-    match __v_3.as_canonical_u64() {
-      5u64 => {
-        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 = 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 __v_24: G = G::from_u64(0);
-        let __v_25: G = G::from_u64(0);
-        let __v_26: G = G::from_u64(0);
-        let __v_27: G = G::from_u64(0);
-        let __v_28: G = G::from_u64(0);
-        let __v_29: G = G::from_u64(0);
-        let __v_30: G = G::from_u64(0);
-        let __v_31: G = G::from_u64(0);
-        let __v_32: G = G::from_u64(0);
-        let __v_33: G = G::from_u64(0);
-        let __v_34: G = G::from_u64(0);
-        let __v_35: G = G::from_u64(0);
-        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; 32] = [__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]; 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_122] = { let __args: [G; IN_122] = [__v_10, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_47: G = __r_arr[0];
-        match __v_47.as_canonical_u64() {
-          1u64 => {
-            let __v_48: G = G::from_u64(0);
-            let __v_49: G = G::from_u64(1);
-            let __v_50: G = G::from_u64(1);
-            let __v_51: G = { let __values: [G; 3] = [__v_49, __v_50, __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_48, __v_0, __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 __ret: [G; OUT_559] = [__v_52];
-            record.function_queries[559].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          0u64 => {
-            let __v_48: G = G::from_u64(0);
-            let __r_arr: [G; OUT_560] = { let __args: [G; IN_560] = [__v_1, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[560].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_560] = unsafe { *(result.output.as_ptr() as *const [G; OUT_560]) }; __ret } else { aiur_fn_560(__args, record, io_buffer, __cu)? } };
-            let __v_49: G = __r_arr[0];
-            let __v_50: G = __r_arr[1];
-            let __v_51: G = __r_arr[2];
-            let __v_52: G = __r_arr[3];
-            let __v_53: G = __r_arr[4];
-            let __v_54: G = __r_arr[5];
-            let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } else { aiur_fn_759(__args, record, io_buffer, __cu)? } };
-            let __v_55: G = __r_arr[0];
-            let __v_56: G = G::from_u64(1);
-            let __v_57: G = G::from_u64(1);
-            let __v_58: G = { let __values: [G; 4] = [__v_56, __v_57, __v_57, __v_57]; 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_774] = { let __args: [G; IN_774] = [__v_55, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[774].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } else { aiur_fn_774(__args, record, io_buffer, __cu)? } };
-            let __v_59: G = __r_arr[0];
-            let __r_arr: [G; OUT_563] = { let __args: [G; IN_563] = [__v_59, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[563].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_563] = unsafe { *(result.output.as_ptr() as *const [G; OUT_563]) }; __ret } else { aiur_fn_563(__args, record, io_buffer, __cu)? } };
-            let __v_60: G = __r_arr[0];
-            let __ret: [G; OUT_559] = [__v_60];
-            record.function_queries[559].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
+    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() {
+      3u64 => {
+        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_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() {
+          2u64 => {
+            let __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[460].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_460] = unsafe { *(result.output.as_ptr() as *const [G; OUT_460]) }; __ret } else { aiur_fn_460(__args, record, io_buffer, __cu)? } };
+            let __v_9: G = __r_arr[0];
+            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_10: G = __r_arr[0];
+            let __r_arr: [G; OUT_461] = { let __args: [G; IN_461] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[461].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_461] = unsafe { *(result.output.as_ptr() as *const [G; OUT_461]) }; __ret } else { aiur_fn_461(__args, record, io_buffer, __cu)? } };
+            let __v_11: G = __r_arr[0];
+            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_12: G = __r_arr[0];
+            let __v_13: G = (__v_10 + __v_12);
+            match __v_13.as_canonical_u64() {
+              0u64 => {
+                let __v_14: G = G::from_u64(0);
+                let __v_15: G = G::from_u64(0);
+                let __v_16: G = G::from_u64(1);
+                let __v_17: G = G::from_u64(1);
+                let __v_18: G = { let __values: [G; 10] = [__v_16, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17]; 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_464] = [__v_14, __v_15, __v_18];
+                record.function_queries[464].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; 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: 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() {
+                  7u64 => {
+                    match __v_15.as_canonical_u64() {
+                      0u64 => {
+                        let __v_18: G = G::from_u64(1);
+                        let __ret: [G; OUT_464] = [__v_18, __v_12, __v_16];
+                        record.function_queries[464].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        return Ok(__ret);
+                      },
+                      _ => {
+                        let __v_18: G = G::from_u64(0);
+                        let __v_19: G = G::from_u64(0);
+                        let __v_20: G = G::from_u64(1);
+                        let __v_21: G = G::from_u64(1);
+                        let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; 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_464] = [__v_18, __v_19, __v_22];
+                        record.function_queries[464].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        return Ok(__ret);
+                      },
+                    }
+                  },
+                  _ => {
+                    let __v_18: G = G::from_u64(0);
+                    let __v_19: G = G::from_u64(0);
+                    let __v_20: G = G::from_u64(1);
+                    let __v_21: G = G::from_u64(1);
+                    let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; 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_464] = [__v_18, __v_19, __v_22];
+                    record.function_queries[464].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
+                  },
+                }
+              },
+            }
           },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_47.as_canonical_u64()));
+            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 = G::from_u64(1);
+            let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; 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_464] = [__v_9, __v_10, __v_13];
+            record.function_queries[464].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
           },
         }
       },
       _ => {
-        let __v_14: G = G::from_u64(0);
-        let __v_15: G = G::from_u64(1);
-        let __v_16: G = G::from_u64(1);
-        let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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_14, __v_0, __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 __ret: [G; OUT_559] = [__v_18];
-        record.function_queries[559].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __v_5: G = G::from_u64(0);
+        let __v_6: G = G::from_u64(0);
+        let __v_7: G = G::from_u64(1);
+        let __v_8: G = G::from_u64(1);
+        let __v_9: G = { let __values: [G; 10] = [__v_7, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8]; 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_464] = [__v_5, __v_6, __v_9];
+        record.function_queries[464].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_560: usize = 2;
-const IN_560: usize = 2;
-const OUT_560: usize = 6;
-fn aiur_fn_560(
-  inp: [G; IN_560],
+const INPUT_SIZE_465: usize = 2;
+const IN_465: usize = 2;
+const OUT_465: usize = 1;
+fn aiur_fn_465(
+  inp: [G; IN_465],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_560], ExecError> {
+) -> Result<[G; OUT_465], 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(1);
-        let __v_6: G = G::from_u64(1);
-        let __ret: [G; OUT_560] = [__v_5, __v_6, __v_6, __v_6, __v_6, __v_6];
-        record.function_queries[560].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].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 = G::from_u64(1);
-        let __v_17: G = (__v_1 + __v_16);
-        let __r_arr: [G; OUT_560] = { let __args: [G; IN_560] = [__v_4, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[560].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_560] = unsafe { *(result.output.as_ptr() as *const [G; OUT_560]) }; __ret } else { aiur_fn_560(__args, record, io_buffer, __cu)? } };
-        let __v_18: G = __r_arr[0];
-        let __v_19: G = __r_arr[1];
-        let __v_20: G = __r_arr[2];
-        let __v_21: G = __r_arr[3];
-        let __v_22: G = __r_arr[4];
-        let __v_23: G = __r_arr[5];
-        match __v_5.as_canonical_u64() {
-          5u64 => {
-            let __v_24: G = G::from_u64(0);
-            let __v_25: G = G::from_u64(0);
-            let __v_26: G = G::from_u64(0);
-            let __v_27: G = G::from_u64(0);
-            let __v_28: G = G::from_u64(0);
-            let __v_29: G = G::from_u64(0);
-            let __v_30: G = G::from_u64(0);
-            let __v_31: G = G::from_u64(0);
-            let __v_32: G = G::from_u64(0);
-            let __v_33: G = G::from_u64(0);
-            let __v_34: G = G::from_u64(0);
-            let __v_35: G = G::from_u64(0);
-            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 = 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 = G::from_u64(0);
-            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 = { let __values: [G; 32] = [__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]; 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_122] = { let __args: [G; IN_122] = [__v_12, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_57: G = __r_arr[0];
-            match __v_57.as_canonical_u64() {
+    let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_0.as_canonical_u64() {
+  0u64 => {
+    let __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[460].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_460] = unsafe { *(result.output.as_ptr() as *const [G; OUT_460]) }; __ret } else { aiur_fn_460(__args, record, io_buffer, __cu)? } };
+    let __v_2: G = __r_arr[0];
+    break '__mc_0 [__v_2];
+  },
+  _ => {
+    let __r_arr: [G; OUT_461] = { let __args: [G; IN_461] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[461].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_461] = unsafe { *(result.output.as_ptr() as *const [G; OUT_461]) }; __ret } else { aiur_fn_461(__args, record, io_buffer, __cu)? } };
+    let __v_2: G = __r_arr[0];
+    break '__mc_0 [__v_2];
+  },
+}
+ };
+    let __v_2: G = __mc_out___mc_0[0];
+    let __v_3: G = G::from_u64(2);
+    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 __v_7: G = G::from_u64(0);
+    let __v_8: G = { let __values: [G; 4] = [__v_3, __v_2, __v_6, __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 __v_9: G = G::from_u64(7);
+    let __v_10: G = G::from_u64(0);
+    let __v_11: G = G::from_u64(0);
+    let __v_12: G = { let __values: [G; 4] = [__v_9, __v_10, __v_1, __v_11]; 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_13: G = G::from_u64(3);
+    let __v_14: G = G::from_u64(0);
+    let __v_15: G = { let __values: [G; 4] = [__v_13, __v_8, __v_12, __v_14]; 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_465] = [__v_15];
+    record.function_queries[465].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_466: usize = 4;
+const IN_466: usize = 4;
+const OUT_466: usize = 2;
+fn aiur_fn_466(
+  inp: [G; IN_466],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_466], 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_711] = { let __args: [G; IN_711] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } else { aiur_fn_711(__args, record, io_buffer, __cu)? } };
+    let __v_4: G = __r_arr[0];
+    let __v_5: G = G::from_u64(2);
+    let __v_6: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_5.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_6.as_canonical_u64() {
+      1u64 => {
+        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 = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __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_466] = [__v_7, __v_11];
+        record.function_queries[466].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __v_7: G = G::from_u64(0);
+        let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } };
+        let __v_8: G = __r_arr[0];
+        let __v_9: G = G::from_u64(1);
+        let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } };
+        let __v_10: G = __r_arr[0];
+        let __r_arr: [G; OUT_464] = { let __args: [G; IN_464] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[464].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_464] = unsafe { *(result.output.as_ptr() as *const [G; OUT_464]) }; __ret } else { aiur_fn_464(__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];
+        match __v_11.as_canonical_u64() {
+          1u64 => {
+            let __r_arr: [G; OUT_464] = { let __args: [G; IN_464] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[464].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_464] = unsafe { *(result.output.as_ptr() as *const [G; OUT_464]) }; __ret } else { aiur_fn_464(__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];
+            match __v_14.as_canonical_u64() {
               1u64 => {
-                let __ret: [G; OUT_560] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23];
-                record.function_queries[560].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              0u64 => {
-                let __r_arr: [G; OUT_561] = { let __args: [G; IN_561] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_12, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[561].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_561] = unsafe { *(result.output.as_ptr() as *const [G; OUT_561]) }; __ret } else { aiur_fn_561(__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];
-                let __v_61: G = __r_arr[3];
-                let __v_62: G = __r_arr[4];
-                let __v_63: G = __r_arr[5];
-                let __ret: [G; OUT_560] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63];
-                record.function_queries[560].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                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 = { let __values: [G; 4] = [__v_18, __v_19, __v_20, __v_20]; 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_466] = [__v_17, __v_21];
+                record.function_queries[466].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                return Err(ExecError::MatchNoCase(__v_57.as_canonical_u64()));
+                let __r_arr: [G; OUT_467] = { let __args: [G; IN_467] = [__v_0, __v_1, __v_2, __v_8, __v_10, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[467].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_467] = unsafe { *(result.output.as_ptr() as *const [G; OUT_467]) }; __ret } else { aiur_fn_467(__args, record, io_buffer, __cu)? } };
+                let __v_17: G = __r_arr[0];
+                let __v_18: G = __r_arr[1];
+                let __ret: [G; OUT_466] = [__v_17, __v_18];
+                record.function_queries[466].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
               },
             }
           },
           _ => {
-            let __ret: [G; OUT_560] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23];
-            record.function_queries[560].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __r_arr: [G; OUT_467] = { let __args: [G; IN_467] = [__v_0, __v_1, __v_2, __v_8, __v_10, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[467].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_467] = unsafe { *(result.output.as_ptr() as *const [G; OUT_467]) }; __ret } else { aiur_fn_467(__args, record, io_buffer, __cu)? } };
+            let __v_14: G = __r_arr[0];
+            let __v_15: G = __r_arr[1];
+            let __ret: [G; OUT_466] = [__v_14, __v_15];
+            record.function_queries[466].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
     }
   })
 }
 
-const INPUT_SIZE_561: usize = 8;
-const IN_561: usize = 8;
-const OUT_561: usize = 6;
-fn aiur_fn_561(
-  inp: [G; IN_561],
+const INPUT_SIZE_467: usize = 6;
+const IN_467: usize = 6;
+const OUT_467: usize = 2;
+fn aiur_fn_467(
+  inp: [G; IN_467],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_561], ExecError> {
+) -> Result<[G; OUT_467], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -48699,161 +39863,227 @@ fn aiur_fn_561(
     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 __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } else { aiur_fn_759(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = unsafe { *(result.output.as_ptr() as *const [G; OUT_377]) }; __ret } else { aiur_fn_377(__args, record, io_buffer, __cu)? } };
+    let __v_6: G = __r_arr[0];
+    let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = unsafe { *(result.output.as_ptr() as *const [G; OUT_377]) }; __ret } else { aiur_fn_377(__args, record, io_buffer, __cu)? } };
+    let __v_7: G = __r_arr[0];
+    let __r_arr: [G; OUT_464] = { let __args: [G; IN_464] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[464].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_464] = unsafe { *(result.output.as_ptr() as *const [G; OUT_464]) }; __ret } else { aiur_fn_464(__args, record, io_buffer, __cu)? } };
     let __v_8: G = __r_arr[0];
-    let __v_9: G = G::from_u64(1);
-    let __v_10: G = G::from_u64(1);
-    let __v_11: G = { let __values: [G; 4] = [__v_9, __v_10, __v_10, __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 __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_8, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[774].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } else { aiur_fn_774(__args, record, io_buffer, __cu)? } };
-    let __v_12: G = __r_arr[0];
-    let __r_arr: [G; OUT_562] = { let __args: [G; IN_562] = [__v_12, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[562].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_562] = unsafe { *(result.output.as_ptr() as *const [G; OUT_562]) }; __ret } else { aiur_fn_562(__args, record, io_buffer, __cu)? } };
-    let __v_13: G = __r_arr[0];
-    let __r_arr: [G; OUT_785] = { let __args: [G; IN_785] = [__v_8, __v_13, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[785].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_785] = unsafe { *(result.output.as_ptr() as *const [G; OUT_785]) }; __ret } else { aiur_fn_785(__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 __v_17: G = __r_arr[3];
-    let __v_18: G = __r_arr[4];
-    let __v_19: G = __r_arr[5];
-    let __ret: [G; OUT_561] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19];
-    record.function_queries[561].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
+    let __v_9: G = __r_arr[1];
+    let __v_10: G = __r_arr[2];
+    match __v_8.as_canonical_u64() {
+      1u64 => {
+        let __r_arr: [G; OUT_464] = { let __args: [G; IN_464] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[464].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_464] = unsafe { *(result.output.as_ptr() as *const [G; OUT_464]) }; __ret } else { aiur_fn_464(__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];
+        match __v_11.as_canonical_u64() {
+          1u64 => {
+            let __r_arr: [G; OUT_465] = { let __args: [G; IN_465] = [__v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[465].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_465] = unsafe { *(result.output.as_ptr() as *const [G; OUT_465]) }; __ret } else { aiur_fn_465(__args, record, io_buffer, __cu)? } };
+            let __v_14: G = __r_arr[0];
+            let __r_arr: [G; OUT_465] = { let __args: [G; IN_465] = [__v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[465].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_465] = unsafe { *(result.output.as_ptr() as *const [G; OUT_465]) }; __ret } else { aiur_fn_465(__args, record, io_buffer, __cu)? } };
+            let __v_15: G = __r_arr[0];
+            let __v_16: G = G::from_u64(2);
+            let __v_17: G = G::from_u64(0);
+            let __v_18: G = { let __values: [G; 4] = [__v_16, __v_0, __v_1, __v_17]; 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_19: G = G::from_u64(3);
+            let __v_20: G = G::from_u64(0);
+            let __v_21: G = { let __values: [G; 4] = [__v_19, __v_18, __v_14, __v_20]; 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_22: G = G::from_u64(3);
+            let __v_23: G = G::from_u64(0);
+            let __v_24: G = { let __values: [G; 4] = [__v_22, __v_21, __v_15, __v_23]; 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_25: G = G::from_u64(2);
+            let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_2, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } };
+            let __v_26: G = __r_arr[0];
+            let __v_27: G = G::from_u64(1);
+            let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_24, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } };
+            let __v_28: G = __r_arr[0];
+            let __ret: [G; OUT_467] = [__v_27, __v_28];
+            record.function_queries[467].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            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 = G::from_u64(0);
+            let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; 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_467] = [__v_14, __v_18];
+            record.function_queries[467].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+        }
+      },
+      _ => {
+        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 = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; 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_467] = [__v_11, __v_15];
+        record.function_queries[467].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+    }
   })
 }
 
-const INPUT_SIZE_562: usize = 3;
-const IN_562: usize = 3;
-const OUT_562: usize = 1;
-fn aiur_fn_562(
-  inp: [G; IN_562],
+const INPUT_SIZE_468: usize = 4;
+const IN_468: usize = 4;
+const OUT_468: usize = 2;
+fn aiur_fn_468(
+  inp: [G; IN_468],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_562], ExecError> {
+) -> Result<[G; OUT_468], 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; 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_3: G = __loaded[0];
-    let __v_4: G = __loaded[1];
-    let __v_5: G = __loaded[2];
-    let __v_6: G = __loaded[3];
-    match __v_3.as_canonical_u64() {
+    let __v_3: G = inp[3];
+    let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } else { aiur_fn_711(__args, record, io_buffer, __cu)? } };
+    let __v_4: G = __r_arr[0];
+    let __v_5: G = G::from_u64(2);
+    let __v_6: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_5.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_6.as_canonical_u64() {
       1u64 => {
         let __v_7: G = G::from_u64(0);
         let __v_8: G = G::from_u64(0);
-        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 __v_12: G = { let __values: [G; 3] = [__v_8, __v_2, __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 __v_13: G = G::from_u64(1);
-        let __v_14: G = G::from_u64(1);
-        let __v_15: G = { let __values: [G; 4] = [__v_13, __v_14, __v_14, __v_14]; 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_16: G = { let __values: [G; 4] = [__v_7, __v_1, __v_12, __v_15]; 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_562] = [__v_16];
-        record.function_queries[562].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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_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_468] = [__v_7, __v_11];
+        record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_463] = { let __args: [G; IN_463] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[463].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_463] = unsafe { *(result.output.as_ptr() as *const [G; OUT_463]) }; __ret } else { aiur_fn_463(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
         match __v_7.as_canonical_u64() {
           1u64 => {
-            let __v_8: G = G::from_u64(0);
-            let __v_9: G = G::from_u64(0);
-            let __v_10: G = { let __values: [G; 3] = [__v_9, __v_2, __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 __v_11: G = { let __values: [G; 4] = [__v_8, __v_4, __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_562] = [__v_11];
-            record.function_queries[562].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          0u64 => {
-            let __v_8: G = G::from_u64(0);
-            let __r_arr: [G; OUT_562] = { let __args: [G; IN_562] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[562].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_562] = unsafe { *(result.output.as_ptr() as *const [G; OUT_562]) }; __ret } else { aiur_fn_562(__args, record, io_buffer, __cu)? } };
-            let __v_9: G = __r_arr[0];
-            let __v_10: G = { let __values: [G; 4] = [__v_8, __v_4, __v_5, __v_9]; 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_562] = [__v_10];
-            record.function_queries[562].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __r_arr: [G; OUT_466] = { let __args: [G; IN_466] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[466].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_466] = unsafe { *(result.output.as_ptr() as *const [G; OUT_466]) }; __ret } else { aiur_fn_466(__args, record, io_buffer, __cu)? } };
+            let __v_8: G = __r_arr[0];
+            let __v_9: G = __r_arr[1];
+            let __ret: [G; OUT_468] = [__v_8, __v_9];
+            record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64()));
+            let __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[446].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_446] = unsafe { *(result.output.as_ptr() as *const [G; OUT_446]) }; __ret } else { aiur_fn_446(__args, record, io_buffer, __cu)? } };
+            let __v_8: G = __r_arr[0];
+            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_9: G = __r_arr[0];
+            let __r_arr: [G; OUT_447] = { let __args: [G; IN_447] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[447].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_447] = unsafe { *(result.output.as_ptr() as *const [G; OUT_447]) }; __ret } else { aiur_fn_447(__args, record, io_buffer, __cu)? } };
+            let __v_10: G = __r_arr[0];
+            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_11: G = __r_arr[0];
+            let __r_arr: [G; OUT_448] = { let __args: [G; IN_448] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[448].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_448] = unsafe { *(result.output.as_ptr() as *const [G; OUT_448]) }; __ret } else { aiur_fn_448(__args, record, io_buffer, __cu)? } };
+            let __v_12: G = __r_arr[0];
+            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_13: G = __r_arr[0];
+            match __v_13.as_canonical_u64() {
+              1u64 => {
+                let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } else { aiur_fn_469(__args, record, io_buffer, __cu)? } };
+                let __v_14: G = __r_arr[0];
+                let __v_15: G = __r_arr[1];
+                let __ret: [G; OUT_468] = [__v_14, __v_15];
+                record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                let __r_arr: [G; OUT_470] = { let __args: [G; IN_470] = [__v_9, __v_11, __v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[470].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_470] = unsafe { *(result.output.as_ptr() as *const [G; OUT_470]) }; __ret } else { aiur_fn_470(__args, record, io_buffer, __cu)? } };
+                let __v_14: G = __r_arr[0];
+                let __v_15: G = __r_arr[1];
+                let __ret: [G; OUT_468] = [__v_14, __v_15];
+                record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+            }
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
-      },
     }
   })
 }
 
-const INPUT_SIZE_563: usize = 2;
-const IN_563: usize = 2;
-const OUT_563: usize = 1;
-fn aiur_fn_563(
-  inp: [G; IN_563],
+const INPUT_SIZE_469: usize = 3;
+const IN_469: usize = 3;
+const OUT_469: usize = 2;
+fn aiur_fn_469(
+  inp: [G; IN_469],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_563], ExecError> {
+) -> Result<[G; OUT_469], 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 __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_563] = [__v_8];
-        record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __v_2: G = inp[2];
+    let __v_3: G = G::from_u64(0);
+    let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } };
+    let __v_4: G = __r_arr[0];
+    let __v_5: G = G::from_u64(1);
+    let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } };
+    let __v_6: G = __r_arr[0];
+    let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = unsafe { *(result.output.as_ptr() as *const [G; OUT_377]) }; __ret } else { aiur_fn_377(__args, record, io_buffer, __cu)? } };
+    let __v_7: G = __r_arr[0];
+    let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[225].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_225] = unsafe { *(result.output.as_ptr() as *const [G; OUT_225]) }; __ret } else { aiur_fn_225(__args, record, io_buffer, __cu)? } };
+    let __v_8: G = __r_arr[0];
+    let __v_9: G = __r_arr[1];
+    match __v_8.as_canonical_u64() {
+      0u64 => {
+        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 = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; 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_469] = [__v_10, __v_14];
+        record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_6: G = __r_arr[0];
-        match __v_6.as_canonical_u64() {
-          1u64 => {
-            let __ret: [G; OUT_563] = [__v_4];
-            record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          0u64 => {
-            let __r_arr: [G; OUT_563] = { let __args: [G; IN_563] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[563].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_563] = unsafe { *(result.output.as_ptr() as *const [G; OUT_563]) }; __ret } else { aiur_fn_563(__args, record, io_buffer, __cu)? } };
-            let __v_7: G = __r_arr[0];
-            let __ret: [G; OUT_563] = [__v_7];
-            record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64()));
-          },
-        }
+      1u64 => {
+        let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { 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_10: G = __r_arr[0];
+        let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } else { aiur_fn_227(__args, record, io_buffer, __cu)? } };
+        let __v_11: G = __r_arr[0];
+        let __v_12: G = G::from_u64(2);
+        let __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[446].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_446] = unsafe { *(result.output.as_ptr() as *const [G; OUT_446]) }; __ret } else { aiur_fn_446(__args, record, io_buffer, __cu)? } };
+        let __v_13: G = __r_arr[0];
+        let __v_14: G = G::from_u64(0);
+        let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_0, __v_14]; 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_16: G = G::from_u64(3);
+        let __v_17: G = G::from_u64(0);
+        let __v_18: G = { let __values: [G; 4] = [__v_16, __v_15, __v_11, __v_17]; 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_19: G = G::from_u64(3);
+        let __v_20: G = G::from_u64(0);
+        let __v_21: G = { let __values: [G; 4] = [__v_19, __v_18, __v_6, __v_20]; 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_22: G = G::from_u64(2);
+        let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_1, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } };
+        let __v_23: G = __r_arr[0];
+        let __v_24: G = G::from_u64(1);
+        let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_21, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } };
+        let __v_25: G = __r_arr[0];
+        let __ret: [G; OUT_469] = [__v_24, __v_25];
+        record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+        return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_564: usize = 6;
-const IN_564: usize = 6;
-const OUT_564: usize = 2;
-fn aiur_fn_564(
-  inp: [G; IN_564],
+const INPUT_SIZE_470: usize = 6;
+const IN_470: usize = 6;
+const OUT_470: usize = 2;
+fn aiur_fn_470(
+  inp: [G; IN_470],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_564], ExecError> {
+) -> Result<[G; OUT_470], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -48861,619 +40091,848 @@ fn aiur_fn_564(
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
-    let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { 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_6: G = __r_arr[0];
-    let __v_7: G = (__v_5 + __v_6);
-    let __r_arr: [G; OUT_565] = { let __args: [G; IN_565] = [__v_0, __v_1, __v_7, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[565].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_565] = unsafe { *(result.output.as_ptr() as *const [G; OUT_565]) }; __ret } else { aiur_fn_565(__args, record, io_buffer, __cu)? } };
-    let __v_8: G = __r_arr[0];
-    let __v_9: G = __r_arr[1];
-    let __ret: [G; OUT_564] = [__v_8, __v_9];
-    record.function_queries[564].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
+    let __v_6: G = G::from_u64(0);
+    let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } };
+    let __v_7: G = __r_arr[0];
+    let __v_8: G = G::from_u64(1);
+    let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } };
+    let __v_9: G = __r_arr[0];
+    let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_7, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = unsafe { *(result.output.as_ptr() as *const [G; OUT_377]) }; __ret } else { aiur_fn_377(__args, record, io_buffer, __cu)? } };
+    let __v_10: G = __r_arr[0];
+    let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_9, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = unsafe { *(result.output.as_ptr() as *const [G; OUT_377]) }; __ret } else { aiur_fn_377(__args, record, io_buffer, __cu)? } };
+    let __v_11: G = __r_arr[0];
+    let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[225].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_225] = unsafe { *(result.output.as_ptr() as *const [G; OUT_225]) }; __ret } else { aiur_fn_225(__args, record, io_buffer, __cu)? } };
+    let __v_12: G = __r_arr[0];
+    let __v_13: G = __r_arr[1];
+    match __v_12.as_canonical_u64() {
+      0u64 => {
+        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 = G::from_u64(0);
+        let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; 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_470] = [__v_14, __v_18];
+        record.function_queries[470].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      1u64 => {
+        let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[225].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_225] = unsafe { *(result.output.as_ptr() as *const [G; OUT_225]) }; __ret } else { aiur_fn_225(__args, record, io_buffer, __cu)? } };
+        let __v_14: G = __r_arr[0];
+        let __v_15: G = __r_arr[1];
+        match __v_14.as_canonical_u64() {
+          0u64 => {
+            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 = { let __values: [G; 4] = [__v_17, __v_18, __v_19, __v_19]; 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_470] = [__v_16, __v_20];
+            record.function_queries[470].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          1u64 => {
+            let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_0.as_canonical_u64() {
+  1u64 => {
+    let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_13, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { 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_16: G = __r_arr[0];
+    break '__mc_0 [__v_16];
+  },
+  _ => {
+    let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_13, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } };
+    let __v_16: G = __r_arr[0];
+    break '__mc_0 [__v_16];
+  },
+}
+ };
+            let __v_16: G = __mc_out___mc_0[0];
+            let __r_arr: [G; OUT_471] = { let __args: [G; IN_471] = [__v_0, __v_1, __v_16, __v_7, __v_9, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[471].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_471] = unsafe { *(result.output.as_ptr() as *const [G; OUT_471]) }; __ret } else { aiur_fn_471(__args, record, io_buffer, __cu)? } };
+            let __v_17: G = __r_arr[0];
+            let __v_18: G = __r_arr[1];
+            let __ret: [G; OUT_470] = [__v_17, __v_18];
+            record.function_queries[470].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64()));
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64()));
+      },
+    }
   })
 }
 
-const INPUT_SIZE_565: usize = 5;
-const IN_565: usize = 5;
-const OUT_565: usize = 2;
-fn aiur_fn_565(
-  inp: [G; IN_565],
+const INPUT_SIZE_471: usize = 9;
+const IN_471: usize = 9;
+const OUT_471: usize = 2;
+fn aiur_fn_471(
+  inp: [G; IN_471],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_565], ExecError> {
+) -> Result<[G; OUT_471], 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(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 __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_0, __v_7, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } };
-    let __v_8: 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_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).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_9: G = __loaded[0];
-    let __v_10: G = __loaded[1];
-    let __v_11: G = __loaded[2];
-    let __v_12: G = __loaded[3];
-    match __v_9.as_canonical_u64() {
-      5u64 => {
-        let __r_arr: [G; OUT_565] = { let __args: [G; IN_565] = [__v_11, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[565].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_565] = unsafe { *(result.output.as_ptr() as *const [G; OUT_565]) }; __ret } else { aiur_fn_565(__args, record, io_buffer, __cu)? } };
-        let __v_13: G = __r_arr[0];
-        let __v_14: G = __r_arr[1];
-        let __ret: [G; OUT_565] = [__v_13, __v_14];
-        record.function_queries[565].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    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 = (__v_9 - __v_2);
+    let __v_11: G = (__v_0 * __v_10);
+    match __v_11.as_canonical_u64() {
+      1u64 => {
+        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 = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; 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_471] = [__v_12, __v_16];
+        record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[189].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_189] = unsafe { *(result.output.as_ptr() as *const [G; OUT_189]) }; __ret } else { aiur_fn_189(__args, record, io_buffer, __cu)? } };
-        let __v_13: G = __r_arr[0];
-        let __v_14: G = __r_arr[1];
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; 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: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
-        let __v_15: G = __loaded[0];
-        let __v_16: G = __loaded[1];
-        let __v_17: G = __loaded[2];
-        let __v_18: G = __loaded[3];
-        match __v_15.as_canonical_u64() {
-          2u64 => {
-            let __v_19: G = G::from_u64(0);
-            let __r_arr: [G; OUT_566] = { let __args: [G; IN_566] = [__v_1, __v_16, __v_14, __v_19, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[566].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_566] = unsafe { *(result.output.as_ptr() as *const [G; OUT_566]) }; __ret } else { aiur_fn_566(__args, record, io_buffer, __cu)? } };
-            let __v_20: G = __r_arr[0];
-            let __v_21: G = __r_arr[1];
-            let __ret: [G; OUT_565] = [__v_20, __v_21];
-            record.function_queries[565].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            let __v_19: G = G::from_u64(0);
-            let __v_20: G = G::from_u64(0);
-            let __ret: [G; OUT_565] = [__v_19, __v_20];
-            record.function_queries[565].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-        }
+        let __v_12: G = G::from_u64(1);
+        let __v_13: G = G::from_u64(0);
+        let __v_14: G = G::from_u64(0);
+        let __v_15: G = { let __values: [G; 3] = [__v_13, __v_14, __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 __v_16: G = G::from_u64(0);
+        let __v_17: G = { let __values: [G; 3] = [__v_12, __v_15, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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 = G::from_u64(0);
+        let __v_19: G = G::from_u64(1);
+        let __v_20: G = G::from_u64(1);
+        let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __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_18, __v_17, __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 = G::from_u64(2);
+        let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[456].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_456] = unsafe { *(result.output.as_ptr() as *const [G; OUT_456]) }; __ret } else { aiur_fn_456(__args, record, io_buffer, __cu)? } };
+        let __v_24: G = __r_arr[0];
+        let __v_25: G = G::from_u64(0);
+        let __v_26: G = { let __values: [G; 4] = [__v_23, __v_24, __v_22, __v_25]; 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_27: G = G::from_u64(2);
+        let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[455].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_455] = unsafe { *(result.output.as_ptr() as *const [G; OUT_455]) }; __ret } else { aiur_fn_455(__args, record, io_buffer, __cu)? } };
+        let __v_28: G = __r_arr[0];
+        let __v_29: G = G::from_u64(1);
+        let __v_30: G = G::from_u64(1);
+        let __v_31: G = { let __values: [G; 3] = [__v_29, __v_30, __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 = G::from_u64(0);
+        let __v_33: G = { let __values: [G; 4] = [__v_27, __v_28, __v_31, __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 __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_2.as_canonical_u64() {
+  1u64 => {
+    let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[155].get_mut(&__args[..]) { 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_34: G = __r_arr[0];
+    break '__mc_0 [__v_34];
+  },
+  _ => {
+    let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { 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_34: G = __r_arr[0];
+    break '__mc_0 [__v_34];
+  },
+}
+ };
+        let __v_34: G = __mc_out___mc_0[0];
+        let __v_35: G = G::from_u64(2);
+        let __v_36: G = G::from_u64(1);
+        let __v_37: G = G::from_u64(1);
+        let __v_38: G = { let __values: [G; 3] = [__v_36, __v_37, __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 = G::from_u64(0);
+        let __v_40: G = { let __values: [G; 4] = [__v_35, __v_34, __v_38, __v_39]; 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_41: G = G::from_u64(3);
+        let __v_42: G = G::from_u64(0);
+        let __v_43: G = { let __values: [G; 4] = [__v_41, __v_26, __v_33, __v_42]; 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_44: G = G::from_u64(3);
+        let __v_45: G = G::from_u64(0);
+        let __v_46: G = { let __values: [G; 4] = [__v_44, __v_43, __v_40, __v_45]; 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 __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_0.as_canonical_u64() {
+  1u64 => {
+    match __v_2.as_canonical_u64() {
+      1u64 => {
+        let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[451].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_451] = unsafe { *(result.output.as_ptr() as *const [G; OUT_451]) }; __ret } else { aiur_fn_451(__args, record, io_buffer, __cu)? } };
+        let __v_47: G = __r_arr[0];
+        break '__mc_1 [__v_47];
+      },
+      _ => {
+        let __r_arr: [G; OUT_452] = { let __args: [G; IN_452] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[452].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_452] = unsafe { *(result.output.as_ptr() as *const [G; OUT_452]) }; __ret } else { aiur_fn_452(__args, record, io_buffer, __cu)? } };
+        let __v_47: G = __r_arr[0];
+        break '__mc_1 [__v_47];
+      },
+    }
+  },
+  _ => {
+    match __v_2.as_canonical_u64() {
+      1u64 => {
+        let __r_arr: [G; OUT_453] = { let __args: [G; IN_453] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[453].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_453] = unsafe { *(result.output.as_ptr() as *const [G; OUT_453]) }; __ret } else { aiur_fn_453(__args, record, io_buffer, __cu)? } };
+        let __v_47: G = __r_arr[0];
+        break '__mc_1 [__v_47];
+      },
+      _ => {
+        let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = unsafe { *(result.output.as_ptr() as *const [G; OUT_454]) }; __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } };
+        let __v_47: G = __r_arr[0];
+        break '__mc_1 [__v_47];
+      },
+    }
+  },
+}
+ };
+        let __v_47: G = __mc_out___mc_1[0];
+        let __v_48: G = G::from_u64(2);
+        let __v_49: G = G::from_u64(1);
+        let __v_50: G = G::from_u64(1);
+        let __v_51: G = { let __values: [G; 3] = [__v_49, __v_50, __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 = G::from_u64(0);
+        let __v_53: G = { let __values: [G; 4] = [__v_48, __v_47, __v_51, __v_52]; 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_54: G = G::from_u64(3);
+        let __v_55: G = G::from_u64(0);
+        let __v_56: G = { let __values: [G; 4] = [__v_54, __v_53, __v_3, __v_55]; 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_57: G = G::from_u64(3);
+        let __v_58: G = G::from_u64(0);
+        let __v_59: G = { let __values: [G; 4] = [__v_57, __v_56, __v_4, __v_58]; 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_60: G = G::from_u64(3);
+        let __v_61: G = G::from_u64(0);
+        let __v_62: G = { let __values: [G; 4] = [__v_60, __v_59, __v_46, __v_61]; 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_474] = { let __args: [G; IN_474] = [__v_2, __v_62, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[474].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_474] = unsafe { *(result.output.as_ptr() as *const [G; OUT_474]) }; __ret } else { aiur_fn_474(__args, record, io_buffer, __cu)? } };
+        let __v_63: G = __r_arr[0];
+        let __v_64: G = __r_arr[1];
+        let __ret: [G; OUT_471] = [__v_63, __v_64];
+        record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_566: usize = 5;
-const IN_566: usize = 5;
-const OUT_566: usize = 2;
-fn aiur_fn_566(
-  inp: [G; IN_566],
+const INPUT_SIZE_472: usize = 3;
+const IN_472: usize = 3;
+const OUT_472: usize = 2;
+fn aiur_fn_472(
+  inp: [G; IN_472],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_566], ExecError> {
+) -> Result<[G; OUT_472], 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 __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; 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: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].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 __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } else { aiur_fn_711(__args, record, io_buffer, __cu)? } };
+    let __v_3: G = __r_arr[0];
+    let __v_4: G = G::from_u64(2);
+    let __v_5: G = { let __a_val = __v_3.as_canonical_u64(); let __b_val = __v_4.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() {
       1u64 => {
-        let __v_11: G = G::from_u64(0);
-        let __v_12: G = G::from_u64(0);
-        let __ret: [G; OUT_566] = [__v_11, __v_12];
-        record.function_queries[566].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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 = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_9]; 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_472] = [__v_6, __v_10];
+        record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __v_11: G = (__v_6 - __v_1);
-        match __v_11.as_canonical_u64() {
-          0u64 => {
-            let __r_arr: [G; OUT_567] = { let __args: [G; IN_567] = [__v_2, __v_8, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[567].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_567] = unsafe { *(result.output.as_ptr() as *const [G; OUT_567]) }; __ret } else { aiur_fn_567(__args, record, io_buffer, __cu)? } };
-            let __v_12: G = __r_arr[0];
-            match __v_12.as_canonical_u64() {
+      _ => {
+        let __v_6: G = G::from_u64(0);
+        let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } };
+        let __v_7: G = __r_arr[0];
+        let __v_8: G = G::from_u64(1);
+        let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_1, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } };
+        let __v_9: 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_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: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].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];
+        match __v_10.as_canonical_u64() {
+          7u64 => {
+            match __v_11.as_canonical_u64() {
               1u64 => {
-                let __v_13: G = G::from_u64(1);
-                let __ret: [G; OUT_566] = [__v_13, __v_3];
-                record.function_queries[566].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
+                let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; 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: 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() {
+                  7u64 => {
+                    match __v_15.as_canonical_u64() {
+                      1u64 => {
+                        let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_12, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } else { aiur_fn_310(__args, record, io_buffer, __cu)? } };
+                        let __v_18: G = __r_arr[0];
+                        match __v_18.as_canonical_u64() {
+                          0u64 => {
+                            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 = { let __values: [G; 4] = [__v_20, __v_21, __v_22, __v_22]; 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_472] = [__v_19, __v_23];
+                            record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            return Ok(__ret);
+                          },
+                          _ => {
+                            let __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__v_12, __v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[473].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_473] = unsafe { *(result.output.as_ptr() as *const [G; OUT_473]) }; __ret } else { aiur_fn_473(__args, record, io_buffer, __cu)? } };
+                            let __v_19: G = __r_arr[0];
+                            let __v_20: G = __r_arr[1];
+                            let __ret: [G; OUT_472] = [__v_19, __v_20];
+                            record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            return Ok(__ret);
+                          },
+                        }
+                      },
+                      _ => {
+                        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 = { let __values: [G; 4] = [__v_19, __v_20, __v_21, __v_21]; 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_472] = [__v_18, __v_22];
+                        record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        return Ok(__ret);
+                      },
+                    }
+                  },
+                  _ => {
+                    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 = { let __values: [G; 4] = [__v_19, __v_20, __v_21, __v_21]; 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_472] = [__v_18, __v_22];
+                    record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
+                  },
+                }
               },
               _ => {
-                let __v_13: G = G::from_u64(1);
-                let __v_14: G = (__v_3 + __v_13);
-                let __r_arr: [G; OUT_566] = { let __args: [G; IN_566] = [__v_10, __v_1, __v_2, __v_14, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[566].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_566] = unsafe { *(result.output.as_ptr() as *const [G; OUT_566]) }; __ret } else { aiur_fn_566(__args, record, io_buffer, __cu)? } };
-                let __v_15: G = __r_arr[0];
-                let __v_16: G = __r_arr[1];
-                let __ret: [G; OUT_566] = [__v_15, __v_16];
-                record.function_queries[566].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                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 = G::from_u64(0);
+                let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; 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_472] = [__v_14, __v_18];
+                record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
           _ => {
-            let __v_12: G = G::from_u64(1);
-            let __v_13: G = (__v_3 + __v_12);
-            let __r_arr: [G; OUT_566] = { let __args: [G; IN_566] = [__v_10, __v_1, __v_2, __v_13, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[566].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_566] = unsafe { *(result.output.as_ptr() as *const [G; OUT_566]) }; __ret } else { aiur_fn_566(__args, record, io_buffer, __cu)? } };
-            let __v_14: G = __r_arr[0];
-            let __v_15: G = __r_arr[1];
-            let __ret: [G; OUT_566] = [__v_14, __v_15];
-            record.function_queries[566].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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 = G::from_u64(0);
+            let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; 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_472] = [__v_14, __v_18];
+            record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
-      },
     }
   })
 }
 
-const INPUT_SIZE_567: usize = 3;
-const IN_567: usize = 3;
-const OUT_567: usize = 1;
-fn aiur_fn_567(
-  inp: [G; IN_567],
+const INPUT_SIZE_473: usize = 4;
+const IN_473: usize = 4;
+const OUT_473: usize = 2;
+fn aiur_fn_473(
+  inp: [G; IN_473],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_567], ExecError> {
+) -> Result<[G; OUT_473], 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_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_3: G = __loaded[0];
-    let __v_4: G = __loaded[1];
-    let __v_5: G = __loaded[2];
-    match __v_3.as_canonical_u64() {
+    let __v_3: G = inp[3];
+    let __v_4: G = G::from_u64(1);
+    let __v_5: G = G::from_u64(0);
+    let __v_6: G = G::from_u64(0);
+    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 __v_8: G = G::from_u64(0);
+    let __v_9: G = { let __values: [G; 3] = [__v_4, __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_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 = { 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 __v_14: G = { let __values: [G; 3] = [__v_10, __v_9, __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_15: G = G::from_u64(2);
+    let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[456].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_456] = unsafe { *(result.output.as_ptr() as *const [G; OUT_456]) }; __ret } else { aiur_fn_456(__args, record, io_buffer, __cu)? } };
+    let __v_16: G = __r_arr[0];
+    let __v_17: G = G::from_u64(0);
+    let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_14, __v_17]; 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_19: G = G::from_u64(2);
+    let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { 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_20: G = __r_arr[0];
+    let __v_21: G = G::from_u64(1);
+    let __v_22: G = G::from_u64(1);
+    let __v_23: G = { let __values: [G; 3] = [__v_21, __v_22, __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 = G::from_u64(0);
+    let __v_25: G = { let __values: [G; 4] = [__v_19, __v_20, __v_23, __v_24]; 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_26: G = G::from_u64(7);
+    let __v_27: G = G::from_u64(1);
+    let __v_28: G = G::from_u64(0);
+    let __v_29: G = { let __values: [G; 4] = [__v_26, __v_27, __v_0, __v_28]; 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_30: G = G::from_u64(3);
+    let __v_31: G = G::from_u64(0);
+    let __v_32: G = { let __values: [G; 4] = [__v_30, __v_18, __v_25, __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 = G::from_u64(3);
+    let __v_34: G = G::from_u64(0);
+    let __v_35: G = { let __values: [G; 4] = [__v_33, __v_32, __v_29, __v_34]; 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_36: G = G::from_u64(2);
+    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 = { let __values: [G; 4] = [__v_36, __v_1, __v_39, __v_40]; 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_42: G = G::from_u64(2);
+    let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_2, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } else { aiur_fn_721(__args, record, io_buffer, __cu)? } };
+    let __v_43: G = __r_arr[0];
+    let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_41, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } };
+    let __v_44: G = __r_arr[0];
+    let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_44, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[434].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_434] = unsafe { *(result.output.as_ptr() as *const [G; OUT_434]) }; __ret } else { aiur_fn_434(__args, record, io_buffer, __cu)? } };
+    let __v_45: G = __r_arr[0];
+    let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_45, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = unsafe { *(result.output.as_ptr() as *const [G; OUT_377]) }; __ret } else { aiur_fn_377(__args, record, io_buffer, __cu)? } };
+    let __v_46: G = __r_arr[0];
+    let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[106].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_106] = unsafe { *(result.output.as_ptr() as *const [G; OUT_106]) }; __ret } else { aiur_fn_106(__args, record, io_buffer, __cu)? } };
+    let __v_47: G = __r_arr[0];
+    let __v_48: G = __r_arr[1];
+    let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } else { aiur_fn_711(__args, record, io_buffer, __cu)? } };
+    let __v_49: G = __r_arr[0];
+    let __v_50: G = G::from_u64(1);
+    let __v_51: G = { let __a_val = __v_49.as_canonical_u64(); let __b_val = __v_50.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_51.as_canonical_u64() {
       1u64 => {
-        let __v_6: G = G::from_u64(1);
-        let __ret: [G; OUT_567] = [__v_6];
-        record.function_queries[567].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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 = { let __values: [G; 4] = [__v_53, __v_54, __v_55, __v_55]; 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_473] = [__v_52, __v_56];
+        record.function_queries[473].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_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_6: G = __loaded[0];
-        let __v_7: G = __loaded[1];
-        let __v_8: G = __loaded[2];
-        match __v_6.as_canonical_u64() {
-          1u64 => {
-            let __v_9: G = G::from_u64(0);
-            let __ret: [G; OUT_567] = [__v_9];
-            record.function_queries[567].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          0u64 => {
-            let __v_9: G = G::from_u64(0);
-            let __r_arr: [G; OUT_413] = { let __args: [G; IN_413] = [__v_4, __v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[413].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_413] = unsafe { *(result.output.as_ptr() as *const [G; OUT_413]) }; __ret } else { aiur_fn_413(__args, record, io_buffer, __cu)? } };
-            let __v_10: G = __r_arr[0];
-            let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } else { aiur_fn_596(__args, record, io_buffer, __cu)? } };
-            let __v_11: G = __r_arr[0];
-            match __v_11.as_canonical_u64() {
-              1u64 => {
-                let __r_arr: [G; OUT_567] = { let __args: [G; IN_567] = [__v_8, __v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[567].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_567] = unsafe { *(result.output.as_ptr() as *const [G; OUT_567]) }; __ret } else { aiur_fn_567(__args, record, io_buffer, __cu)? } };
-                let __v_12: G = __r_arr[0];
-                let __ret: [G; OUT_567] = [__v_12];
-                record.function_queries[567].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              _ => {
-                let __v_12: G = G::from_u64(0);
-                let __ret: [G; OUT_567] = [__v_12];
-                record.function_queries[567].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()));
+        let __v_52: G = G::from_u64(0);
+        let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_48, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } };
+        let __v_53: G = __r_arr[0];
+        let __v_54: G = G::from_u64(2);
+        let __r_arr: [G; OUT_449] = { let __args: [G; IN_449] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[449].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_449] = unsafe { *(result.output.as_ptr() as *const [G; OUT_449]) }; __ret } else { aiur_fn_449(__args, record, io_buffer, __cu)? } };
+        let __v_55: G = __r_arr[0];
+        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 __v_59: G = G::from_u64(0);
+        let __v_60: G = { let __values: [G; 4] = [__v_54, __v_55, __v_58, __v_59]; 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_61: G = G::from_u64(3);
+        let __v_62: G = G::from_u64(0);
+        let __v_63: G = { let __values: [G; 4] = [__v_61, __v_60, __v_53, __v_62]; 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_64: G = G::from_u64(3);
+        let __v_65: G = G::from_u64(0);
+        let __v_66: G = { let __values: [G; 4] = [__v_64, __v_63, __v_35, __v_65]; 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_67: G = G::from_u64(2);
+        let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_2, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } };
+        let __v_68: G = __r_arr[0];
+        let __v_69: G = G::from_u64(1);
+        let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_66, __v_68]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } };
+        let __v_70: G = __r_arr[0];
+        let __ret: [G; OUT_473] = [__v_69, __v_70];
+        record.function_queries[473].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_568: usize = 1;
-const IN_568: usize = 1;
-const OUT_568: usize = 2;
-fn aiur_fn_568(
-  inp: [G; IN_568],
+const INPUT_SIZE_474: usize = 6;
+const IN_474: usize = 6;
+const OUT_474: usize = 2;
+fn aiur_fn_474(
+  inp: [G; IN_474],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_568], ExecError> {
+) -> Result<[G; OUT_474], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __v_1: G = G::from_u64(1);
-    let __v_2: G = G::from_u64(1);
-    let __v_3: G = { let __values: [G; 3] = [__v_1, __v_2, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_569] = { let __args: [G; IN_569] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[569].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_569] = unsafe { *(result.output.as_ptr() as *const [G; OUT_569]) }; __ret } else { aiur_fn_569(__args, record, io_buffer, __cu)? } };
-    let __v_4: G = __r_arr[0];
-    let __v_5: G = __r_arr[1];
-    let __r_arr: [G; OUT_776] = { let __args: [G; IN_776] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[776].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_776] = unsafe { *(result.output.as_ptr() as *const [G; OUT_776]) }; __ret } else { aiur_fn_776(__args, record, io_buffer, __cu)? } };
+    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 __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_0.as_canonical_u64() {
+  1u64 => {
+    let __r_arr: [G; OUT_449] = { let __args: [G; IN_449] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[449].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_449] = unsafe { *(result.output.as_ptr() as *const [G; OUT_449]) }; __ret } else { aiur_fn_449(__args, record, io_buffer, __cu)? } };
     let __v_6: G = __r_arr[0];
-    let __ret: [G; OUT_568] = [__v_6, __v_5];
-    record.function_queries[568].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
-  })
+    break '__mc_0 [__v_6];
+  },
+  _ => {
+    let __r_arr: [G; OUT_450] = { let __args: [G; IN_450] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[450].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_450] = unsafe { *(result.output.as_ptr() as *const [G; OUT_450]) }; __ret } else { aiur_fn_450(__args, record, io_buffer, __cu)? } };
+    let __v_6: G = __r_arr[0];
+    break '__mc_0 [__v_6];
+  },
 }
-
-const INPUT_SIZE_569: usize = 2;
-const IN_569: usize = 2;
-const OUT_569: usize = 2;
-fn aiur_fn_569(
-  inp: [G; IN_569],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_569], 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() {
-      5u64 => {
-        let __v_6: G = G::from_u64(0);
-        let __v_7: G = { let __values: [G; 3] = [__v_6, __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_569] = { let __args: [G; IN_569] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[569].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_569] = unsafe { *(result.output.as_ptr() as *const [G; OUT_569]) }; __ret } else { aiur_fn_569(__args, record, io_buffer, __cu)? } };
-        let __v_8: G = __r_arr[0];
-        let __v_9: G = __r_arr[1];
-        let __ret: [G; OUT_569] = [__v_8, __v_9];
-        record.function_queries[569].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+ };
+    let __v_6: G = __mc_out___mc_0[0];
+    let __v_7: G = G::from_u64(2);
+    let __v_8: G = G::from_u64(0);
+    let __v_9: G = { let __values: [G; 4] = [__v_7, __v_2, __v_3, __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 __v_10: G = G::from_u64(2);
+    let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_4, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } else { aiur_fn_721(__args, record, io_buffer, __cu)? } };
+    let __v_11: G = __r_arr[0];
+    let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_9, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } };
+    let __v_12: G = __r_arr[0];
+    let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_12, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[434].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_434] = unsafe { *(result.output.as_ptr() as *const [G; OUT_434]) }; __ret } else { aiur_fn_434(__args, record, io_buffer, __cu)? } };
+    let __v_13: G = __r_arr[0];
+    let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_13, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = unsafe { *(result.output.as_ptr() as *const [G; OUT_377]) }; __ret } else { aiur_fn_377(__args, record, io_buffer, __cu)? } };
+    let __v_14: G = __r_arr[0];
+    let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[106].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_106] = unsafe { *(result.output.as_ptr() as *const [G; OUT_106]) }; __ret } else { aiur_fn_106(__args, record, io_buffer, __cu)? } };
+    let __v_15: G = __r_arr[0];
+    let __v_16: G = __r_arr[1];
+    let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } else { aiur_fn_711(__args, record, io_buffer, __cu)? } };
+    let __v_17: G = __r_arr[0];
+    let __v_18: G = G::from_u64(1);
+    let __v_19: G = { let __a_val = __v_17.as_canonical_u64(); let __b_val = __v_18.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_19.as_canonical_u64() {
+      1u64 => {
+        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 __v_24: G = { let __values: [G; 4] = [__v_21, __v_22, __v_23, __v_23]; 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_474] = [__v_20, __v_24];
+        record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __ret: [G; OUT_569] = [__v_1, __v_0];
-        record.function_queries[569].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __v_20: G = G::from_u64(0);
+        let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_16, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } };
+        let __v_21: G = __r_arr[0];
+        let __v_22: G = G::from_u64(2);
+        let __v_23: G = G::from_u64(1);
+        let __v_24: G = G::from_u64(1);
+        let __v_25: G = { let __values: [G; 3] = [__v_23, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_26: G = G::from_u64(0);
+        let __v_27: G = { let __values: [G; 4] = [__v_22, __v_6, __v_25, __v_26]; 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_28: G = G::from_u64(3);
+        let __v_29: G = G::from_u64(0);
+        let __v_30: G = { let __values: [G; 4] = [__v_28, __v_27, __v_21, __v_29]; 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_31: G = G::from_u64(3);
+        let __v_32: G = G::from_u64(0);
+        let __v_33: G = { let __values: [G; 4] = [__v_31, __v_30, __v_1, __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 = G::from_u64(2);
+        let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_4, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } };
+        let __v_35: G = __r_arr[0];
+        let __v_36: G = G::from_u64(1);
+        let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_33, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } };
+        let __v_37: G = __r_arr[0];
+        let __ret: [G; OUT_474] = [__v_36, __v_37];
+        record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_570: usize = 3;
-const IN_570: usize = 3;
-const OUT_570: usize = 1;
-fn aiur_fn_570(
-  inp: [G; IN_570],
+const INPUT_SIZE_475: usize = 2;
+const IN_475: usize = 2;
+const OUT_475: usize = 1;
+fn aiur_fn_475(
+  inp: [G; IN_475],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_570], ExecError> {
+) -> Result<[G; OUT_475], 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_570] = [__v_8];
-        record.function_queries[570].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
+    let __v_2: G = (__v_0 - __v_1);
+    match __v_2.as_canonical_u64() {
       0u64 => {
-        let __v_6: G = G::from_u64(0);
-        let __r_arr: [G; OUT_413] = { let __args: [G; IN_413] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[413].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_413] = unsafe { *(result.output.as_ptr() as *const [G; OUT_413]) }; __ret } else { aiur_fn_413(__args, record, io_buffer, __cu)? } };
-        let __v_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[570].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_570] = unsafe { *(result.output.as_ptr() as *const [G; OUT_570]) }; __ret } else { aiur_fn_570(__args, record, io_buffer, __cu)? } };
-        let __v_8: G = __r_arr[0];
-        let __v_9: G = { let __values: [G; 3] = [__v_6, __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 __ret: [G; OUT_570] = [__v_9];
-        record.function_queries[570].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __v_3: G = G::from_u64(1);
+        let __ret: [G; OUT_475] = [__v_3];
+        record.function_queries[475].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
+        let __v_3: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_1.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_3.as_canonical_u64() {
+          1u64 => {
+            let __v_4: G = G::from_u64(0);
+            let __ret: [G; OUT_475] = [__v_4];
+            record.function_queries[475].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          0u64 => {
+            let __v_4: G = G::from_u64(2);
+            let __ret: [G; OUT_475] = [__v_4];
+            record.function_queries[475].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
+          },
+        }
       },
     }
   })
 }
 
-const INPUT_SIZE_571: usize = 4;
-const IN_571: usize = 4;
-const OUT_571: usize = 1;
-fn aiur_fn_571(
-  inp: [G; IN_571],
+const INPUT_SIZE_476: usize = 2;
+const IN_476: usize = 2;
+const OUT_476: usize = 1;
+fn aiur_fn_476(
+  inp: [G; IN_476],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_571], ExecError> {
+) -> Result<[G; OUT_476], 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_1 - __v_3);
-    match __v_4.as_canonical_u64() {
-      0u64 => {
-        let __ret: [G; OUT_571] = [__v_0];
-        record.function_queries[571].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    match __v_0.as_canonical_u64() {
+      1u64 => {
+        let __ret: [G; OUT_476] = [__v_1];
+        record.function_queries[476].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __v_5: G = G::from_u64(0);
-        let __v_6: G = (__v_2 - __v_3);
-        let __v_7: G = G::from_u64(0);
-        let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __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 __v_9: G = G::from_u64(3);
-        let __v_10: G = G::from_u64(0);
-        let __v_11: G = { let __values: [G; 4] = [__v_9, __v_0, __v_8, __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 __v_12: G = G::from_u64(1);
-        let __v_13: G = (__v_3 + __v_12);
-        let __r_arr: [G; OUT_571] = { let __args: [G; IN_571] = [__v_11, __v_1, __v_2, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[571].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_571] = unsafe { *(result.output.as_ptr() as *const [G; OUT_571]) }; __ret } else { aiur_fn_571(__args, record, io_buffer, __cu)? } };
-        let __v_14: G = __r_arr[0];
-        let __ret: [G; OUT_571] = [__v_14];
-        record.function_queries[571].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_476] = [__v_0];
+        record.function_queries[476].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_572: usize = 4;
-const IN_572: usize = 4;
-const OUT_572: usize = 1;
-fn aiur_fn_572(
-  inp: [G; IN_572],
+const INPUT_SIZE_477: usize = 0;
+const IN_477: usize = 0;
+const OUT_477: usize = 2;
+fn aiur_fn_477(
+  inp: [G; IN_477],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_572], ExecError> {
+) -> Result<[G; OUT_477], 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_1 - __v_3);
-    match __v_4.as_canonical_u64() {
-      0u64 => {
-        let __ret: [G; OUT_572] = [__v_0];
-        record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        let __v_5: G = G::from_u64(0);
-        let __v_6: G = G::from_u64(1);
-        let __v_7: G = (__v_2 - __v_6);
-        let __v_8: G = (__v_7 - __v_3);
-        let __v_9: G = G::from_u64(0);
-        let __v_10: G = { let __values: [G; 4] = [__v_5, __v_8, __v_9, __v_9]; 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_11: G = G::from_u64(3);
-        let __v_12: G = G::from_u64(0);
-        let __v_13: G = { let __values: [G; 4] = [__v_11, __v_0, __v_10, __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 __v_14: G = G::from_u64(1);
-        let __v_15: G = (__v_3 + __v_14);
-        let __r_arr: [G; OUT_572] = { let __args: [G; IN_572] = [__v_13, __v_1, __v_2, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[572].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_572] = unsafe { *(result.output.as_ptr() as *const [G; OUT_572]) }; __ret } else { aiur_fn_572(__args, record, io_buffer, __cu)? } };
-        let __v_16: G = __r_arr[0];
-        let __ret: [G; OUT_572] = [__v_16];
-        record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-    }
+    let __v_0: G = G::from_u64(0);
+    let __v_1: G = G::from_u64(1);
+    let __ret: [G; OUT_477] = [__v_0, __v_1];
+    record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_573: usize = 2;
-const IN_573: usize = 2;
-const OUT_573: usize = 2;
-fn aiur_fn_573(
-  inp: [G; IN_573],
+const INPUT_SIZE_478: usize = 0;
+const IN_478: usize = 0;
+const OUT_478: usize = 2;
+fn aiur_fn_478(
+  inp: [G; IN_478],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_573], ExecError> {
+) -> Result<[G; OUT_478], 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_574] = { let __args: [G; IN_574] = [__v_0, __v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } else { aiur_fn_574(__args, record, io_buffer, __cu)? } };
-    let __v_5: G = __r_arr[0];
-    let __v_6: G = __r_arr[1];
-    let __r_arr: [G; OUT_776] = { let __args: [G; IN_776] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[776].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_776] = unsafe { *(result.output.as_ptr() as *const [G; OUT_776]) }; __ret } else { aiur_fn_776(__args, record, io_buffer, __cu)? } };
-    let __v_7: G = __r_arr[0];
-    let __ret: [G; OUT_573] = [__v_7, __v_6];
-    record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __v_0: G = G::from_u64(1);
+    let __v_1: G = G::from_u64(1);
+    let __ret: [G; OUT_478] = [__v_0, __v_1];
+    record.function_queries[478].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_574: usize = 3;
-const IN_574: usize = 3;
-const OUT_574: usize = 2;
-fn aiur_fn_574(
-  inp: [G; IN_574],
+const INPUT_SIZE_479: usize = 0;
+const IN_479: usize = 0;
+const OUT_479: usize = 2;
+fn aiur_fn_479(
+  inp: [G; IN_479],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_574], ExecError> {
+) -> Result<[G; OUT_479], 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_1.as_canonical_u64() {
-      0u64 => {
-        let __ret: [G; OUT_574] = [__v_2, __v_0];
-        record.function_queries[574].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        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_3: G = __loaded[0];
-        let __v_4: G = __loaded[1];
-        let __v_5: G = __loaded[2];
-        let __v_6: G = __loaded[3];
-        match __v_3.as_canonical_u64() {
-          5u64 => {
-            let __v_7: G = G::from_u64(1);
-            let __v_8: G = (__v_1 - __v_7);
-            let __v_9: G = G::from_u64(0);
-            let __v_10: G = { let __values: [G; 3] = [__v_9, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_574] = { let __args: [G; IN_574] = [__v_5, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } else { aiur_fn_574(__args, record, io_buffer, __cu)? } };
-            let __v_11: G = __r_arr[0];
-            let __v_12: G = __r_arr[1];
-            let __ret: [G; OUT_574] = [__v_11, __v_12];
-            record.function_queries[574].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
-          },
-        }
-      },
-    }
+    let __v_0: G = G::from_u64(2);
+    let __v_1: G = G::from_u64(1);
+    let __ret: [G; OUT_479] = [__v_0, __v_1];
+    record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_575: usize = 3;
-const IN_575: usize = 3;
-const OUT_575: usize = 1;
-fn aiur_fn_575(
-  inp: [G; IN_575],
+const INPUT_SIZE_480: usize = 4;
+const IN_480: usize = 4;
+const OUT_480: usize = 2;
+fn aiur_fn_480(
+  inp: [G; IN_480],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_575], ExecError> {
+) -> Result<[G; OUT_480], 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 = (__v_1 - __v_2);
-    match __v_3.as_canonical_u64() {
-      0u64 => {
-        let __ret: [G; OUT_575] = [__v_0];
-        record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __v_3: G = inp[3];
+    match __v_0.as_canonical_u64() {
+      1u64 => {
+        let __v_4: G = (__v_1 * __v_3);
+        let __ret: [G; OUT_480] = [__v_2, __v_4];
+        record.function_queries[480].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __v_4: G = G::from_u64(0);
-        let __v_5: G = (__v_1 - __v_2);
-        let __v_6: G = G::from_u64(0);
-        let __v_7: G = { let __values: [G; 4] = [__v_4, __v_5, __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 __v_8: G = G::from_u64(3);
-        let __v_9: G = G::from_u64(0);
-        let __v_10: G = { let __values: [G; 4] = [__v_8, __v_0, __v_7, __v_9]; 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_11: G = G::from_u64(1);
-        let __v_12: G = (__v_2 + __v_11);
-        let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_10, __v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[575].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_575] = unsafe { *(result.output.as_ptr() as *const [G; OUT_575]) }; __ret } else { aiur_fn_575(__args, record, io_buffer, __cu)? } };
-        let __v_13: G = __r_arr[0];
-        let __ret: [G; OUT_575] = [__v_13];
-        record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_480] = [__v_0, __v_1];
+        record.function_queries[480].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_576: usize = 15;
-const IN_576: usize = 15;
-const OUT_576: usize = 1;
-fn aiur_fn_576(
-  inp: [G; IN_576],
+const INPUT_SIZE_481: usize = 1;
+const IN_481: usize = 1;
+const OUT_481: usize = 2;
+fn aiur_fn_481(
+  inp: [G; IN_481],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_576], ExecError> {
+) -> Result<[G; OUT_481], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = G::from_u64(1);
+    let __ret: [G; OUT_481] = [__v_0, __v_1];
+    record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_482: usize = 2;
+const IN_482: usize = 2;
+const OUT_482: usize = 1;
+fn aiur_fn_482(
+  inp: [G; IN_482],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_482], 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 __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_15: G = __loaded[0];
-    let __v_16: G = __loaded[1];
-    let __v_17: G = __loaded[2];
-    match __v_15.as_canonical_u64() {
-      1u64 => {
-        let __v_18: G = G::from_u64(1);
-        let __v_19: G = G::from_u64(1);
-        let __v_20: G = { let __values: [G; 3] = [__v_18, __v_19, __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 __ret: [G; OUT_576] = [__v_20];
-        record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_12, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-        let __v_18: G = __r_arr[0];
-        let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].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];
-        match __v_19.as_canonical_u64() {
-          6u64 => {
-            let __r_arr: [G; OUT_556] = { let __args: [G; IN_556] = [__v_1, __v_16, __v_21, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_14, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[556].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_556] = unsafe { *(result.output.as_ptr() as *const [G; OUT_556]) }; __ret } else { aiur_fn_556(__args, record, io_buffer, __cu)? } };
-            let __v_30: G = __r_arr[0];
-            let __v_31: G = G::from_u64(1);
-            let __v_32: G = (__v_14 + __v_31);
-            let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_17, __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_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[576].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_576] = unsafe { *(result.output.as_ptr() as *const [G; OUT_576]) }; __ret } else { aiur_fn_576(__args, record, io_buffer, __cu)? } };
-            let __v_33: G = __r_arr[0];
-            let __v_34: G = G::from_u64(0);
-            let __v_35: G = { let __values: [G; 3] = [__v_34, __v_30, __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 __ret: [G; OUT_576] = [__v_35];
-            record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_19.as_canonical_u64()));
-          },
-        }
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_15.as_canonical_u64()));
-      },
-    }
+    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_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];
+    let __v_12: G = __loaded[10];
+    let __v_13: G = __loaded[11];
+    let __v_14: G = __loaded[12];
+    let __v_15: G = __loaded[13];
+    let __v_16: G = __loaded[14];
+    let __v_17: G = __loaded[15];
+    let __v_18: G = __loaded[16];
+    let __v_19: G = __loaded[17];
+    let __v_20: G = __loaded[18];
+    let __v_21: G = __loaded[19];
+    let __v_22: G = __loaded[20];
+    let __v_23: G = __loaded[21];
+    let __v_24: G = __loaded[22];
+    let __v_25: G = __loaded[23];
+    let __v_26: G = __loaded[24];
+    let __v_27: G = __loaded[25];
+    let __v_28: G = __loaded[26];
+    let __v_29: G = __loaded[27];
+    let __v_30: G = __loaded[28];
+    let __v_31: G = __loaded[29];
+    let __v_32: G = __loaded[30];
+    let __v_33: 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_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 __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_2, __v_3, __v_4, __v_5, __v_34, __v_35, __v_36, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } else { aiur_fn_483(__args, record, io_buffer, __cu)? } };
+    let __v_66: G = __r_arr[0];
+    let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_6, __v_7, __v_8, __v_9, __v_38, __v_39, __v_40, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } else { aiur_fn_483(__args, record, io_buffer, __cu)? } };
+    let __v_67: G = __r_arr[0];
+    let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_10, __v_11, __v_12, __v_13, __v_42, __v_43, __v_44, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } else { aiur_fn_483(__args, record, io_buffer, __cu)? } };
+    let __v_68: G = __r_arr[0];
+    let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_14, __v_15, __v_16, __v_17, __v_46, __v_47, __v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } else { aiur_fn_483(__args, record, io_buffer, __cu)? } };
+    let __v_69: G = __r_arr[0];
+    let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_18, __v_19, __v_20, __v_21, __v_50, __v_51, __v_52, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } else { aiur_fn_483(__args, record, io_buffer, __cu)? } };
+    let __v_70: G = __r_arr[0];
+    let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_22, __v_23, __v_24, __v_25, __v_54, __v_55, __v_56, __v_57]; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } else { aiur_fn_483(__args, record, io_buffer, __cu)? } };
+    let __v_71: G = __r_arr[0];
+    let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_26, __v_27, __v_28, __v_29, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } else { aiur_fn_483(__args, record, io_buffer, __cu)? } };
+    let __v_72: G = __r_arr[0];
+    let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_30, __v_31, __v_32, __v_33, __v_62, __v_63, __v_64, __v_65]; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } else { aiur_fn_483(__args, record, io_buffer, __cu)? } };
+    let __v_73: G = __r_arr[0];
+    let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_72, __v_73]; let __cu = unconstrained; if let Some(result) = record.function_queries[476].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_476] = unsafe { *(result.output.as_ptr() as *const [G; OUT_476]) }; __ret } else { aiur_fn_476(__args, record, io_buffer, __cu)? } };
+    let __v_74: G = __r_arr[0];
+    let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_71, __v_74]; let __cu = unconstrained; if let Some(result) = record.function_queries[476].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_476] = unsafe { *(result.output.as_ptr() as *const [G; OUT_476]) }; __ret } else { aiur_fn_476(__args, record, io_buffer, __cu)? } };
+    let __v_75: G = __r_arr[0];
+    let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_70, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[476].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_476] = unsafe { *(result.output.as_ptr() as *const [G; OUT_476]) }; __ret } else { aiur_fn_476(__args, record, io_buffer, __cu)? } };
+    let __v_76: G = __r_arr[0];
+    let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_69, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[476].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_476] = unsafe { *(result.output.as_ptr() as *const [G; OUT_476]) }; __ret } else { aiur_fn_476(__args, record, io_buffer, __cu)? } };
+    let __v_77: G = __r_arr[0];
+    let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_68, __v_77]; let __cu = unconstrained; if let Some(result) = record.function_queries[476].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_476] = unsafe { *(result.output.as_ptr() as *const [G; OUT_476]) }; __ret } else { aiur_fn_476(__args, record, io_buffer, __cu)? } };
+    let __v_78: G = __r_arr[0];
+    let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_67, __v_78]; let __cu = unconstrained; if let Some(result) = record.function_queries[476].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_476] = unsafe { *(result.output.as_ptr() as *const [G; OUT_476]) }; __ret } else { aiur_fn_476(__args, record, io_buffer, __cu)? } };
+    let __v_79: G = __r_arr[0];
+    let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_66, __v_79]; let __cu = unconstrained; if let Some(result) = record.function_queries[476].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_476] = unsafe { *(result.output.as_ptr() as *const [G; OUT_476]) }; __ret } else { aiur_fn_476(__args, record, io_buffer, __cu)? } };
+    let __v_80: G = __r_arr[0];
+    let __ret: [G; OUT_482] = [__v_80];
+    record.function_queries[482].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_577: usize = 8;
-const IN_577: usize = 8;
-const OUT_577: usize = 1;
-fn aiur_fn_577(
-  inp: [G; IN_577],
+const INPUT_SIZE_483: usize = 8;
+const IN_483: usize = 8;
+const OUT_483: usize = 1;
+fn aiur_fn_483(
+  inp: [G; IN_483],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_577], ExecError> {
+) -> Result<[G; OUT_483], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -49483,616 +40942,567 @@ fn aiur_fn_577(
     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(0);
-    let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__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[578].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_578] = unsafe { *(result.output.as_ptr() as *const [G; OUT_578]) }; __ret } else { aiur_fn_578(__args, record, io_buffer, __cu)? } };
-    let __v_9: G = __r_arr[0];
-    let __ret: [G; OUT_577] = [__v_9];
-    record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __v_8: G = G::from_u64(16777216);
+    let __v_9: G = (__v_0 * __v_8);
+    let __v_10: G = G::from_u64(65536);
+    let __v_11: G = (__v_1 * __v_10);
+    let __v_12: G = G::from_u64(256);
+    let __v_13: G = (__v_2 * __v_12);
+    let __v_14: G = (__v_13 + __v_3);
+    let __v_15: G = (__v_11 + __v_14);
+    let __v_16: G = (__v_9 + __v_15);
+    let __v_17: G = G::from_u64(16777216);
+    let __v_18: G = (__v_4 * __v_17);
+    let __v_19: G = G::from_u64(65536);
+    let __v_20: G = (__v_5 * __v_19);
+    let __v_21: G = G::from_u64(256);
+    let __v_22: G = (__v_6 * __v_21);
+    let __v_23: G = (__v_22 + __v_7);
+    let __v_24: G = (__v_20 + __v_23);
+    let __v_25: G = (__v_18 + __v_24);
+    let __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_16, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[475].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_475] = unsafe { *(result.output.as_ptr() as *const [G; OUT_475]) }; __ret } else { aiur_fn_475(__args, record, io_buffer, __cu)? } };
+    let __v_26: G = __r_arr[0];
+    let __ret: [G; OUT_483] = [__v_26];
+    record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_578: usize = 9;
-const IN_578: usize = 9;
-const OUT_578: usize = 1;
-fn aiur_fn_578(
-  inp: [G; IN_578],
+const INPUT_SIZE_484: usize = 2;
+const IN_484: usize = 2;
+const OUT_484: usize = 1;
+fn aiur_fn_484(
+  inp: [G; IN_484],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_578], ExecError> {
+) -> Result<[G; OUT_484], 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; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; 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: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].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];
-    match __v_9.as_canonical_u64() {
+    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_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 __v_15: G = G::from_u64(1);
-        let __v_16: G = G::from_u64(1);
-        let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_578] = [__v_17];
-        record.function_queries[578].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __v_6: G = G::from_u64(0);
+        let __ret: [G; OUT_484] = [__v_6];
+        record.function_queries[484].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_6, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-        let __v_15: G = __r_arr[0];
-        let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr };
-        let __v_16: G = __loaded[0];
-        let __v_17: G = __loaded[1];
-        let __v_18: G = __loaded[2];
-        let __v_19: G = __loaded[3];
-        let __v_20: G = __loaded[4];
-        let __v_21: G = __loaded[5];
-        let __v_22: G = __loaded[6];
-        let __v_23: G = __loaded[7];
-        let __v_24: G = __loaded[8];
-        let __v_25: G = __loaded[9];
-        let __v_26: G = __loaded[10];
-        match __v_16.as_canonical_u64() {
-          5u64 => {
-            let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_10, __v_18, __v_19, __v_20, __v_13, __v_3, __v_5, __v_11, __v_12, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } else { aiur_fn_542(__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_413] = { let __args: [G; IN_413] = [__v_27, __v_8, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[413].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_413] = unsafe { *(result.output.as_ptr() as *const [G; OUT_413]) }; __ret } else { aiur_fn_413(__args, record, io_buffer, __cu)? } };
-            let __v_29: G = __r_arr[0];
-            let __v_30: G = G::from_u64(0);
-            let __v_31: G = G::from_u64(1);
-            let __v_32: G = (__v_8 + __v_31);
-            let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_14, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[578].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_578] = unsafe { *(result.output.as_ptr() as *const [G; OUT_578]) }; __ret } else { aiur_fn_578(__args, record, io_buffer, __cu)? } };
-            let __v_33: G = __r_arr[0];
-            let __v_34: G = { let __values: [G; 3] = [__v_30, __v_29, __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 __ret: [G; OUT_578] = [__v_34];
-            record.function_queries[578].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_6: G = __r_arr[0];
+        match __v_6.as_canonical_u64() {
+          1u64 => {
+            let __v_7: G = G::from_u64(1);
+            let __v_8: G = (__v_7 + __v_4);
+            let __ret: [G; OUT_484] = [__v_8];
+            record.function_queries[484].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_14, __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[578].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_578] = unsafe { *(result.output.as_ptr() as *const [G; OUT_578]) }; __ret } else { aiur_fn_578(__args, record, io_buffer, __cu)? } };
-            let __v_27: G = __r_arr[0];
-            let __ret: [G; OUT_578] = [__v_27];
-            record.function_queries[578].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } else { aiur_fn_484(__args, record, io_buffer, __cu)? } };
+            let __v_7: G = __r_arr[0];
+            let __ret: [G; OUT_484] = [__v_7];
+            record.function_queries[484].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64()));
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_579: usize = 11;
-const IN_579: usize = 11;
-const OUT_579: usize = 1;
-fn aiur_fn_579(
-  inp: [G; IN_579],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_579], 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_580] = { let __args: [G; IN_580] = [__v_0, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[580].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_580] = unsafe { *(result.output.as_ptr() as *const [G; OUT_580]) }; __ret } else { aiur_fn_580(__args, record, io_buffer, __cu)? } };
-    let __v_12: G = __r_arr[0];
-    let __ret: [G; OUT_579] = [__v_12];
-    record.function_queries[579].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_580: usize = 13;
-const IN_580: usize = 13;
-const OUT_580: usize = 1;
-fn aiur_fn_580(
-  inp: [G; IN_580],
+const INPUT_SIZE_485: usize = 3;
+const IN_485: usize = 3;
+const OUT_485: usize = 2;
+fn aiur_fn_485(
+  inp: [G; IN_485],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_580], ExecError> {
+) -> Result<[G; OUT_485], 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 __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; 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: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
-    let __v_13: G = __loaded[0];
-    let __v_14: G = __loaded[1];
-    let __v_15: G = __loaded[2];
-    let __v_16: G = __loaded[3];
-    let __v_17: G = __loaded[4];
-    let __v_18: G = __loaded[5];
-    match __v_13.as_canonical_u64() {
+    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_3: G = __r_arr[0];
+    match __v_3.as_canonical_u64() {
       1u64 => {
-        let __v_19: G = G::from_u64(1);
-        let __v_20: G = G::from_u64(1);
-        let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __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 __ret: [G; OUT_580] = [__v_21];
-        record.function_queries[580].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_478] = { let __args: [G; IN_478] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[478].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_478] = unsafe { *(result.output.as_ptr() as *const [G; OUT_478]) }; __ret } else { aiur_fn_478(__args, record, io_buffer, __cu)? } };
+        let __v_4: G = __r_arr[0];
+        let __v_5: G = __r_arr[1];
+        let __ret: [G; OUT_485] = [__v_4, __v_5];
+        record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_9, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-        let __v_19: G = __r_arr[0];
-        let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr };
-        let __v_20: G = __loaded[0];
-        let __v_21: G = __loaded[1];
-        let __v_22: G = __loaded[2];
-        let __v_23: G = __loaded[3];
-        let __v_24: G = __loaded[4];
-        let __v_25: G = __loaded[5];
-        let __v_26: G = __loaded[6];
-        let __v_27: G = __loaded[7];
-        let __v_28: G = __loaded[8];
-        let __v_29: G = __loaded[9];
-        let __v_30: G = __loaded[10];
-        match __v_20.as_canonical_u64() {
-          5u64 => {
-            let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_25, __v_14, __v_15, __v_16, __v_17, __v_1, __v_2, __v_3, __v_4, __v_5, __v_8, __v_12, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[576].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_576] = unsafe { *(result.output.as_ptr() as *const [G; OUT_576]) }; __ret } else { aiur_fn_576(__args, record, io_buffer, __cu)? } };
-            let __v_31: G = __r_arr[0];
-            let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { 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_32: G = __r_arr[0];
-            let __v_33: G = (__v_11 + __v_32);
-            let __v_34: G = G::from_u64(1);
-            let __v_35: G = (__v_12 + __v_34);
-            let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_18, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_33, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[580].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_580] = unsafe { *(result.output.as_ptr() as *const [G; OUT_580]) }; __ret } else { aiur_fn_580(__args, record, io_buffer, __cu)? } };
-            let __v_36: G = __r_arr[0];
-            let __r_arr: [G; OUT_773] = { let __args: [G; IN_773] = [__v_31, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[773].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_773] = unsafe { *(result.output.as_ptr() as *const [G; OUT_773]) }; __ret } else { aiur_fn_773(__args, record, io_buffer, __cu)? } };
-            let __v_37: G = __r_arr[0];
-            let __ret: [G; OUT_580] = [__v_37];
-            record.function_queries[580].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
+      _ => {
+        let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } else { aiur_fn_484(__args, record, io_buffer, __cu)? } };
+        let __v_4: G = __r_arr[0];
+        let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } else { aiur_fn_484(__args, record, io_buffer, __cu)? } };
+        let __v_5: G = __r_arr[0];
+        match __v_4.as_canonical_u64() {
+          0u64 => {
+            match __v_5.as_canonical_u64() {
+              0u64 => {
+                let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } };
+                let __v_6: G = __r_arr[0];
+                let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } };
+                let __v_7: G = __r_arr[0];
+                let __v_8: G = __r_arr[1];
+                let __ret: [G; OUT_485] = [__v_7, __v_8];
+                record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                let __r_arr: [G; OUT_479] = { let __args: [G; IN_479] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[479].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_479] = unsafe { *(result.output.as_ptr() as *const [G; OUT_479]) }; __ret } else { aiur_fn_479(__args, record, io_buffer, __cu)? } };
+                let __v_6: G = __r_arr[0];
+                let __v_7: G = __r_arr[1];
+                let __ret: [G; OUT_485] = [__v_6, __v_7];
+                record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+            }
           },
           _ => {
-            let __v_31: G = G::from_u64(1);
-            let __v_32: G = (__v_12 + __v_31);
-            let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_18, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[580].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_580] = unsafe { *(result.output.as_ptr() as *const [G; OUT_580]) }; __ret } else { aiur_fn_580(__args, record, io_buffer, __cu)? } };
-            let __v_33: G = __r_arr[0];
-            let __ret: [G; OUT_580] = [__v_33];
-            record.function_queries[580].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
+            match __v_5.as_canonical_u64() {
+              0u64 => {
+                let __r_arr: [G; OUT_477] = { let __args: [G; IN_477] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[477].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_477] = unsafe { *(result.output.as_ptr() as *const [G; OUT_477]) }; __ret } else { aiur_fn_477(__args, record, io_buffer, __cu)? } };
+                let __v_6: G = __r_arr[0];
+                let __v_7: G = __r_arr[1];
+                let __ret: [G; OUT_485] = [__v_6, __v_7];
+                record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                let __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[475].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_475] = unsafe { *(result.output.as_ptr() as *const [G; OUT_475]) }; __ret } else { aiur_fn_475(__args, record, io_buffer, __cu)? } };
+                let __v_6: G = __r_arr[0];
+                let __v_7: G = G::from_u64(0);
+                let __ret: [G; OUT_485] = [__v_6, __v_7];
+                record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+            }
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64()));
-      },
     }
   })
 }
 
-const INPUT_SIZE_581: usize = 4;
-const IN_581: usize = 4;
-const OUT_581: usize = 2;
-fn aiur_fn_581(
-  inp: [G; IN_581],
+const INPUT_SIZE_486: usize = 2;
+const IN_486: usize = 2;
+const OUT_486: usize = 1;
+fn aiur_fn_486(
+  inp: [G; IN_486],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_581], ExecError> {
+) -> Result<[G; OUT_486], 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_1.as_canonical_u64() {
+    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_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_581] = [__v_6, __v_0];
-        record.function_queries[581].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_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_5: G = __loaded[0];
+        let __v_6: G = __loaded[1];
+        let __v_7: G = __loaded[2];
+        match __v_5.as_canonical_u64() {
+          0u64 => {
+            let __v_8: G = G::from_u64(1);
+            let __ret: [G; OUT_486] = [__v_8];
+            record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            let __v_8: G = G::from_u64(0);
+            let __ret: [G; OUT_486] = [__v_8];
+            record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+        }
       },
-      _ => {
-        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_439] = { let __args: [G; IN_439] = [__v_0, __v_6, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } };
-        let __v_7: 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_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: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].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];
-        match __v_8.as_canonical_u64() {
-          5u64 => {
-            let __v_12: G = G::from_u64(1);
-            let __v_13: G = (__v_1 - __v_12);
-            let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_10, __v_13, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[581].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_581] = unsafe { *(result.output.as_ptr() as *const [G; OUT_581]) }; __ret } else { aiur_fn_581(__args, record, io_buffer, __cu)? } };
-            let __v_14: G = __r_arr[0];
-            let __v_15: G = __r_arr[1];
-            let __v_16: G = G::from_u64(0);
-            let __v_17: G = { let __values: [G; 3] = [__v_16, __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_581] = [__v_17, __v_15];
-            record.function_queries[581].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+      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_5: G = __loaded[0];
+        let __v_6: G = __loaded[1];
+        let __v_7: G = __loaded[2];
+        match __v_5.as_canonical_u64() {
+          0u64 => {
+            let __v_8: G = G::from_u64(2);
+            let __ret: [G; OUT_486] = [__v_8];
+            record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          1u64 => {
+            let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } };
+            let __v_8: G = __r_arr[0];
+            let __ret: [G; OUT_486] = [__v_8];
+            record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __v_12: G = G::from_u64(1);
-            let __v_13: G = G::from_u64(1);
-            let __v_14: G = { let __values: [G; 3] = [__v_12, __v_13, __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 __ret: [G; OUT_581] = [__v_14, __v_7];
-            record.function_queries[581].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __v_8: G = G::from_u64(0);
+            let __ret: [G; OUT_486] = [__v_8];
+            record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+        }
+      },
+      2u64 => {
+        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_5: G = __loaded[0];
+        let __v_6: G = __loaded[1];
+        let __v_7: G = __loaded[2];
+        match __v_5.as_canonical_u64() {
+          0u64 => {
+            let __v_8: G = G::from_u64(2);
+            let __ret: [G; OUT_486] = [__v_8];
+            record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          1u64 => {
+            let __v_8: G = G::from_u64(2);
+            let __ret: [G; OUT_486] = [__v_8];
+            record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          2u64 => {
+            let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } };
+            let __v_8: G = __r_arr[0];
+            let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } };
+            let __v_9: G = __r_arr[0];
+            let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[476].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_476] = unsafe { *(result.output.as_ptr() as *const [G; OUT_476]) }; __ret } else { aiur_fn_476(__args, record, io_buffer, __cu)? } };
+            let __v_10: G = __r_arr[0];
+            let __ret: [G; OUT_486] = [__v_10];
+            record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            let __v_8: G = G::from_u64(0);
+            let __ret: [G; OUT_486] = [__v_8];
+            record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+        }
+      },
+      3u64 => {
+        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_5: G = __loaded[0];
+        let __v_6: G = __loaded[1];
+        let __v_7: G = __loaded[2];
+        match __v_5.as_canonical_u64() {
+          0u64 => {
+            let __v_8: G = G::from_u64(2);
+            let __ret: [G; OUT_486] = [__v_8];
+            record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          1u64 => {
+            let __v_8: G = G::from_u64(2);
+            let __ret: [G; OUT_486] = [__v_8];
+            record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          2u64 => {
+            let __v_8: G = G::from_u64(2);
+            let __ret: [G; OUT_486] = [__v_8];
+            record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          3u64 => {
+            let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } };
+            let __v_8: G = __r_arr[0];
+            let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } };
+            let __v_9: G = __r_arr[0];
+            let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[476].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_476] = unsafe { *(result.output.as_ptr() as *const [G; OUT_476]) }; __ret } else { aiur_fn_476(__args, record, io_buffer, __cu)? } };
+            let __v_10: G = __r_arr[0];
+            let __ret: [G; OUT_486] = [__v_10];
+            record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          4u64 => {
+            let __v_8: G = G::from_u64(0);
+            let __ret: [G; OUT_486] = [__v_8];
+            record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
+          },
+        }
+      },
+      4u64 => {
+        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_5: G = __loaded[0];
+        let __v_6: G = __loaded[1];
+        let __v_7: G = __loaded[2];
+        match __v_5.as_canonical_u64() {
+          4u64 => {
+            let __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[475].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_475] = unsafe { *(result.output.as_ptr() as *const [G; OUT_475]) }; __ret } else { aiur_fn_475(__args, record, io_buffer, __cu)? } };
+            let __v_8: G = __r_arr[0];
+            let __ret: [G; OUT_486] = [__v_8];
+            record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            let __v_8: G = G::from_u64(2);
+            let __ret: [G; OUT_486] = [__v_8];
+            record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
     }
   })
 }
 
-const INPUT_SIZE_582: usize = 11;
-const IN_582: usize = 11;
-const OUT_582: usize = 1;
-fn aiur_fn_582(
-  inp: [G; IN_582],
+const INPUT_SIZE_487: usize = 2;
+const IN_487: usize = 2;
+const OUT_487: usize = 1;
+fn aiur_fn_487(
+  inp: [G; IN_487],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_582], ExecError> {
+) -> Result<[G; OUT_487], 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 = (__v_6 + __v_4);
-    let __v_12: G = G::from_u64(1);
-    let __v_13: G = G::from_u64(1);
-    let __v_14: G = { let __values: [G; 3] = [__v_12, __v_13, __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 __r_arr: [G; OUT_519] = { let __args: [G; IN_519] = [__v_1, __v_11, __v_14, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[519].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_519] = unsafe { *(result.output.as_ptr() as *const [G; OUT_519]) }; __ret } else { aiur_fn_519(__args, record, io_buffer, __cu)? } };
-    let __v_15: G = __r_arr[0];
-    let __r_arr: [G; OUT_537] = { let __args: [G; IN_537] = [__v_15, __v_2, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[537].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_537] = unsafe { *(result.output.as_ptr() as *const [G; OUT_537]) }; __ret } else { aiur_fn_537(__args, record, io_buffer, __cu)? } };
-    let __v_16: G = __r_arr[0];
-    let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_16.as_canonical_u64() {
-  1u64 => {
-    let __v_17: G = G::from_u64(4);
-    let __v_18: G = G::from_u64(0);
-    let __v_19: G = G::from_u64(0);
-    let __v_20: G = { let __values: [G; 3] = [__v_17, __v_18, __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 } };
-    break '__mc_0 [__v_20];
-  },
-  0u64 => {
-    let __v_17: G = G::from_u64(0);
-    let __v_18: G = G::from_u64(0);
-    let __v_19: G = { let __values: [G; 3] = [__v_17, __v_18, __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 } };
-    break '__mc_0 [__v_19];
-  },
-  _ => {
-    return Err(ExecError::MatchNoCase(__v_16.as_canonical_u64()));
-  },
-}
- };
-    let __v_17: G = __mc_out___mc_0[0];
-    let __r_arr: [G; OUT_559] = { let __args: [G; IN_559] = [__v_7, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[559].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_559] = unsafe { *(result.output.as_ptr() as *const [G; OUT_559]) }; __ret } else { aiur_fn_559(__args, record, io_buffer, __cu)? } };
-    let __v_18: G = __r_arr[0];
-    let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_18, __v_16, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } };
-    let __v_19: G = __r_arr[0];
-    let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = unsafe { *(result.output.as_ptr() as *const [G; OUT_608]) }; __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } };
-    let __v_20: G = __r_arr[0];
-    let __r_arr: [G; OUT_794] = { let __args: [G; IN_794] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[794].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_794] = unsafe { *(result.output.as_ptr() as *const [G; OUT_794]) }; __ret } else { aiur_fn_794(__args, record, io_buffer, __cu)? } };
-    let __v_21: G = __r_arr[0];
-    let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_9, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-    let __v_22: G = __r_arr[0];
-    let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr };
-    let __v_23: G = __loaded[0];
-    let __v_24: G = __loaded[1];
-    let __v_25: G = __loaded[2];
-    let __v_26: G = __loaded[3];
-    let __v_27: G = __loaded[4];
-    let __v_28: G = __loaded[5];
-    let __v_29: G = __loaded[6];
-    let __v_30: G = __loaded[7];
-    let __v_31: G = __loaded[8];
-    let __v_32: G = __loaded[9];
-    let __v_33: G = __loaded[10];
-    let __mc_out___mc_1: [G; 2] = '__mc_1: { match __v_23.as_canonical_u64() {
-  5u64 => {
-    let __v_34: G = G::from_u64(0);
-    let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_16, __v_24, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[552].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_552] = unsafe { *(result.output.as_ptr() as *const [G; OUT_552]) }; __ret } else { aiur_fn_552(__args, record, io_buffer, __cu)? } };
-    let __v_35: G = __r_arr[0];
-    let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_25, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } };
-    let __v_36: G = __r_arr[0];
-    let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_36, __v_3, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[581].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_581] = unsafe { *(result.output.as_ptr() as *const [G; OUT_581]) }; __ret } else { aiur_fn_581(__args, record, io_buffer, __cu)? } };
-    let __v_37: G = __r_arr[0];
-    let __v_38: G = __r_arr[1];
-    break '__mc_1 [__v_37, __v_38];
-  },
-  _ => {
-    let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_1, __v_3, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[581].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_581] = unsafe { *(result.output.as_ptr() as *const [G; OUT_581]) }; __ret } else { aiur_fn_581(__args, record, io_buffer, __cu)? } };
-    let __v_34: G = __r_arr[0];
-    let __v_35: G = __r_arr[1];
-    break '__mc_1 [__v_34, __v_35];
-  },
-}
- };
-    let __v_34: G = __mc_out___mc_1[0];
-    let __v_35: G = __mc_out___mc_1[1];
-    let __r_arr: [G; OUT_633] = { let __args: [G; IN_633] = [__v_19, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[633].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_633] = unsafe { *(result.output.as_ptr() as *const [G; OUT_633]) }; __ret } else { aiur_fn_633(__args, record, io_buffer, __cu)? } };
-    let __v_36: G = __r_arr[0];
-    let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_19, __v_3, __v_5, __v_17, __v_16, __v_3, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } else { aiur_fn_577(__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_579] = { let __args: [G; IN_579] = [__v_19, __v_20, __v_36, __v_3, __v_21, __v_5, __v_16, __v_3, __v_9, __v_10, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[579].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_579] = unsafe { *(result.output.as_ptr() as *const [G; OUT_579]) }; __ret } else { aiur_fn_579(__args, record, io_buffer, __cu)? } };
-    let __v_39: G = __r_arr[0];
-    let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { 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_40: G = __r_arr[0];
-    let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_35, __v_4, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[551].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_551] = unsafe { *(result.output.as_ptr() as *const [G; OUT_551]) }; __ret } else { aiur_fn_551(__args, record, io_buffer, __cu)? } };
-    let __v_41: G = __r_arr[0];
-    let __v_42: G = (__v_21 + __v_40);
-    let __v_43: G = G::from_u64(0);
-    let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_41, __v_42, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } };
-    let __v_44: G = __r_arr[0];
-    let __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__v_19, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[609].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_609] = unsafe { *(result.output.as_ptr() as *const [G; OUT_609]) }; __ret } else { aiur_fn_609(__args, record, io_buffer, __cu)? } };
-    let __v_45: G = __r_arr[0];
-    let __v_46: G = __r_arr[1];
-    let __v_47: G = __r_arr[2];
-    let __v_48: G = __r_arr[3];
-    let __v_49: G = G::from_u64(2);
-    let __v_50: G = G::from_u64(0);
-    let __v_51: G = { let __values: [G; 4] = [__v_49, __v_0, __v_48, __v_50]; 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_52: G = (__v_40 + __v_4);
-    let __v_53: G = (__v_21 + __v_52);
-    let __v_54: G = (__v_3 + __v_53);
-    let __v_55: G = G::from_u64(1);
-    let __v_56: G = (__v_54 - __v_55);
-    let __v_57: G = (__v_40 + __v_4);
-    let __v_58: G = (__v_21 + __v_57);
-    let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_51, __v_3, __v_56, __v_58, __v_46, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[632].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_632] = unsafe { *(result.output.as_ptr() as *const [G; OUT_632]) }; __ret } else { aiur_fn_632(__args, record, io_buffer, __cu)? } };
-    let __v_59: G = __r_arr[0];
-    let __v_60: G = G::from_u64(0);
-    let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_59, __v_4, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[554].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_554] = unsafe { *(result.output.as_ptr() as *const [G; OUT_554]) }; __ret } else { aiur_fn_554(__args, record, io_buffer, __cu)? } };
-    let __v_61: G = __r_arr[0];
-    let __v_62: G = G::from_u64(1);
-    let __v_63: G = (__v_54 + __v_62);
-    let __v_64: G = G::from_u64(1);
-    let __v_65: G = (__v_63 - __v_64);
-    let __v_66: G = (__v_3 + __v_8);
-    let __v_67: G = (__v_65 - __v_66);
-    let __v_68: G = G::from_u64(0);
-    let __v_69: G = G::from_u64(0);
-    let __v_70: G = { let __values: [G; 4] = [__v_68, __v_67, __v_69, __v_69]; 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_71: G = G::from_u64(0);
-    let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_70, __v_4, __v_71]; let __cu = unconstrained; if let Some(result) = record.function_queries[575].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_575] = unsafe { *(result.output.as_ptr() as *const [G; OUT_575]) }; __ret } else { aiur_fn_575(__args, record, io_buffer, __cu)? } };
-    let __v_72: G = __r_arr[0];
-    let __v_73: G = G::from_u64(3);
-    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 = { let __values: [G; 4] = [__v_74, __v_75, __v_76, __v_76]; 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_78: G = G::from_u64(0);
-    let __v_79: G = { let __values: [G; 4] = [__v_73, __v_72, __v_77, __v_78]; 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_80: G = G::from_u64(5);
-    let __v_81: G = G::from_u64(0);
-    let __v_82: G = { let __values: [G; 4] = [__v_80, __v_61, __v_79, __v_81]; 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_555] = { let __args: [G; IN_555] = [__v_82, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[555].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_555] = unsafe { *(result.output.as_ptr() as *const [G; OUT_555]) }; __ret } else { aiur_fn_555(__args, record, io_buffer, __cu)? } };
-    let __v_83: G = __r_arr[0];
-    let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_83, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[555].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_555] = unsafe { *(result.output.as_ptr() as *const [G; OUT_555]) }; __ret } else { aiur_fn_555(__args, record, io_buffer, __cu)? } };
-    let __v_84: G = __r_arr[0];
-    let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_84, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[555].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_555] = unsafe { *(result.output.as_ptr() as *const [G; OUT_555]) }; __ret } else { aiur_fn_555(__args, record, io_buffer, __cu)? } };
-    let __v_85: G = __r_arr[0];
-    let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_85, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[555].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_555] = unsafe { *(result.output.as_ptr() as *const [G; OUT_555]) }; __ret } else { aiur_fn_555(__args, record, io_buffer, __cu)? } };
-    let __v_86: G = __r_arr[0];
-    let __ret: [G; OUT_582] = [__v_86];
-    record.function_queries[582].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() {
+      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_5: G = __loaded[0];
+        let __v_6: G = __loaded[1];
+        let __v_7: G = __loaded[2];
+        match __v_5.as_canonical_u64() {
+          1u64 => {
+            let __v_8: G = G::from_u64(1);
+            let __ret: [G; OUT_487] = [__v_8];
+            record.function_queries[487].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            let __v_8: G = G::from_u64(0);
+            let __ret: [G; OUT_487] = [__v_8];
+            record.function_queries[487].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_5: G = __loaded[0];
+        let __v_6: G = __loaded[1];
+        let __v_7: G = __loaded[2];
+        match __v_5.as_canonical_u64() {
+          1u64 => {
+            let __v_8: G = G::from_u64(2);
+            let __ret: [G; OUT_487] = [__v_8];
+            record.function_queries[487].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          0u64 => {
+            let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } };
+            let __v_8: G = __r_arr[0];
+            let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } };
+            let __v_9: G = __r_arr[0];
+            let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[476].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_476] = unsafe { *(result.output.as_ptr() as *const [G; OUT_476]) }; __ret } else { aiur_fn_476(__args, record, io_buffer, __cu)? } };
+            let __v_10: G = __r_arr[0];
+            let __ret: [G; OUT_487] = [__v_10];
+            record.function_queries[487].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
   })
 }
 
-const INPUT_SIZE_583: usize = 22;
-const IN_583: usize = 22;
-const OUT_583: usize = 1;
-fn aiur_fn_583(
-  inp: [G; IN_583],
+const INPUT_SIZE_488: usize = 4;
+const IN_488: usize = 4;
+const OUT_488: usize = 1;
+fn aiur_fn_488(
+  inp: [G; IN_488],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_583], ExecError> {
+) -> Result<[G; OUT_488], 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 = (__v_8 + __v_9);
-    let __v_23: G = G::from_u64(0);
-    let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[584].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_584] = unsafe { *(result.output.as_ptr() as *const [G; OUT_584]) }; __ret } else { aiur_fn_584(__args, record, io_buffer, __cu)? } };
-    let __v_24: G = __r_arr[0];
-    let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_3, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } };
-    let __v_25: G = __r_arr[0];
-    let __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = [__v_2, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[548].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_548] = unsafe { *(result.output.as_ptr() as *const [G; OUT_548]) }; __ret } else { aiur_fn_548(__args, record, io_buffer, __cu)? } };
-    let __v_26: G = __r_arr[0];
-    let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = [__v_25, __v_26, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[547].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_547] = unsafe { *(result.output.as_ptr() as *const [G; OUT_547]) }; __ret } else { aiur_fn_547(__args, record, io_buffer, __cu)? } };
-    let __v_27: G = __r_arr[0];
-    let __v_28: G = G::from_u64(1);
-    let __v_29: G = G::from_u64(1);
-    let __v_30: G = { let __values: [G; 3] = [__v_28, __v_29, __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 = G::from_u64(1);
-    let __v_32: G = G::from_u64(1);
-    let __v_33: G = { let __values: [G; 3] = [__v_31, __v_32, __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 = G::from_u64(1);
-    let __v_35: G = G::from_u64(1);
-    let __v_36: G = { let __values: [G; 3] = [__v_34, __v_35, __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 = 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 __r_arr: [G; OUT_558] = { let __args: [G; IN_558] = [__v_27, __v_14, __v_30, __v_33, __v_36, __v_39, __v_20, __v_21, __v_40, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[558].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_558] = unsafe { *(result.output.as_ptr() as *const [G; OUT_558]) }; __ret } else { aiur_fn_558(__args, record, io_buffer, __cu)? } };
-    let __v_42: G = __r_arr[0];
-    let __v_43: G = __r_arr[1];
-    let __v_44: G = __r_arr[2];
-    let __v_45: G = __r_arr[3];
-    let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { 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_46: G = __r_arr[0];
-    let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { 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_47: G = __r_arr[0];
-    let __v_48: G = (__v_7 + __v_46);
-    let __v_49: G = (__v_6 + __v_48);
-    let __v_50: G = (__v_5 + __v_49);
-    let __v_51: G = G::from_u64(1);
-    let __v_52: G = (__v_50 - __v_51);
-    let __v_53: G = (__v_6 + __v_4);
-    let __v_54: G = (__v_5 + __v_53);
-    let __v_55: G = (__v_52 - __v_54);
-    let __v_56: G = G::from_u64(0);
-    let __v_57: G = G::from_u64(0);
-    let __v_58: G = { let __values: [G; 4] = [__v_56, __v_55, __v_57, __v_57]; 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_59: G = G::from_u64(0);
-    let __r_arr: [G; OUT_572] = { let __args: [G; IN_572] = [__v_58, __v_46, __v_46, __v_59]; let __cu = unconstrained; if let Some(result) = record.function_queries[572].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_572] = unsafe { *(result.output.as_ptr() as *const [G; OUT_572]) }; __ret } else { aiur_fn_572(__args, record, io_buffer, __cu)? } };
-    let __v_60: G = __r_arr[0];
-    let __v_61: G = G::from_u64(1);
-    let __v_62: G = G::from_u64(1);
-    let __v_63: G = { let __values: [G; 3] = [__v_61, __v_62, __v_62]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_64: G = G::from_u64(0);
-    let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_60, __v_43, __v_44, __v_42, __v_13, __v_16, __v_5, __v_6, __v_7, __v_46, __v_24, __v_63, __v_20, __v_21, __v_64]; let __cu = unconstrained; if let Some(result) = record.function_queries[586].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_586] = unsafe { *(result.output.as_ptr() as *const [G; OUT_586]) }; __ret } else { aiur_fn_586(__args, record, io_buffer, __cu)? } };
-    let __v_65: G = __r_arr[0];
-    let __v_66: G = (__v_6 + __v_7);
-    let __v_67: G = G::from_u64(0);
-    let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_42, __v_66, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } };
-    let __v_68: G = __r_arr[0];
-    let __r_arr: [G; OUT_585] = { let __args: [G; IN_585] = [__v_65, __v_68]; let __cu = unconstrained; if let Some(result) = record.function_queries[585].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_585] = unsafe { *(result.output.as_ptr() as *const [G; OUT_585]) }; __ret } else { aiur_fn_585(__args, record, io_buffer, __cu)? } };
-    let __v_69: G = __r_arr[0];
-    let __r_arr: [G; OUT_585] = { let __args: [G; IN_585] = [__v_69, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[585].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_585] = unsafe { *(result.output.as_ptr() as *const [G; OUT_585]) }; __ret } else { aiur_fn_585(__args, record, io_buffer, __cu)? } };
-    let __v_70: G = __r_arr[0];
-    let __r_arr: [G; OUT_585] = { let __args: [G; IN_585] = [__v_70, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[585].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_585] = unsafe { *(result.output.as_ptr() as *const [G; OUT_585]) }; __ret } else { aiur_fn_585(__args, record, io_buffer, __cu)? } };
-    let __v_71: G = __r_arr[0];
-    let __r_arr: [G; OUT_585] = { let __args: [G; IN_585] = [__v_71, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[585].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_585] = unsafe { *(result.output.as_ptr() as *const [G; OUT_585]) }; __ret } else { aiur_fn_585(__args, record, io_buffer, __cu)? } };
-    let __v_72: G = __r_arr[0];
-    let __ret: [G; OUT_583] = [__v_72];
-    record.function_queries[583].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        match __v_2.as_canonical_u64() {
+          0u64 => {
+            let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[489].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_489] = unsafe { *(result.output.as_ptr() as *const [G; OUT_489]) }; __ret } else { aiur_fn_489(__args, record, io_buffer, __cu)? } };
+            let __v_4: G = __r_arr[0];
+            let __ret: [G; OUT_488] = [__v_4];
+            record.function_queries[488].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          1u64 => {
+            let __v_4: G = G::from_u64(0);
+            let __ret: [G; OUT_488] = [__v_4];
+            record.function_queries[488].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+          },
+        }
+      },
+      1u64 => {
+        match __v_2.as_canonical_u64() {
+          0u64 => {
+            let __v_4: G = G::from_u64(2);
+            let __ret: [G; OUT_488] = [__v_4];
+            record.function_queries[488].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          1u64 => {
+            let __r_arr: [G; OUT_492] = { let __args: [G; IN_492] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[492].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_492] = unsafe { *(result.output.as_ptr() as *const [G; OUT_492]) }; __ret } else { aiur_fn_492(__args, record, io_buffer, __cu)? } };
+            let __v_4: G = __r_arr[0];
+            let __ret: [G; OUT_488] = [__v_4];
+            record.function_queries[488].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64()));
+      },
+    }
   })
 }
 
-const INPUT_SIZE_584: usize = 2;
-const IN_584: usize = 2;
-const OUT_584: usize = 1;
-fn aiur_fn_584(
-  inp: [G; IN_584],
+const INPUT_SIZE_489: usize = 2;
+const IN_489: usize = 2;
+const OUT_489: usize = 1;
+fn aiur_fn_489(
+  inp: [G; IN_489],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_584], ExecError> {
+) -> Result<[G; OUT_489], 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);
-    match __v_2.as_canonical_u64() {
-      0u64 => {
-        let __v_3: G = G::from_u64(1);
-        let __v_4: G = G::from_u64(1);
-        let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __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 __ret: [G; OUT_584] = [__v_5];
-        record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { 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_2: G = __r_arr[0];
+    let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = unsafe { *(result.output.as_ptr() as *const [G; OUT_714]) }; __ret } else { aiur_fn_714(__args, record, io_buffer, __cu)? } };
+    let __v_4: G = __r_arr[0];
+    let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = unsafe { *(result.output.as_ptr() as *const [G; OUT_714]) }; __ret } else { aiur_fn_714(__args, record, io_buffer, __cu)? } };
+    let __v_5: G = __r_arr[0];
+    let __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[475].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_475] = unsafe { *(result.output.as_ptr() as *const [G; OUT_475]) }; __ret } else { aiur_fn_475(__args, record, io_buffer, __cu)? } };
+    let __v_6: G = __r_arr[0];
+    match __v_6.as_canonical_u64() {
+      1u64 => {
+        let __r_arr: [G; OUT_490] = { let __args: [G; IN_490] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[490].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_490] = unsafe { *(result.output.as_ptr() as *const [G; OUT_490]) }; __ret } else { aiur_fn_490(__args, record, io_buffer, __cu)? } };
+        let __v_7: G = __r_arr[0];
+        let __ret: [G; OUT_489] = [__v_7];
+        record.function_queries[489].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(4);
-        let __v_5: G = G::from_u64(0);
-        let __v_6: G = { let __values: [G; 3] = [__v_4, __v_1, __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 __v_7: G = G::from_u64(1);
-        let __v_8: G = (__v_1 + __v_7);
-        let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[584].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_584] = unsafe { *(result.output.as_ptr() as *const [G; OUT_584]) }; __ret } else { aiur_fn_584(__args, record, io_buffer, __cu)? } };
-        let __v_9: G = __r_arr[0];
-        let __v_10: G = { let __values: [G; 3] = [__v_3, __v_6, __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 __ret: [G; OUT_584] = [__v_10];
-        record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_489] = [__v_6];
+        record.function_queries[489].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_585: usize = 2;
-const IN_585: usize = 2;
-const OUT_585: usize = 1;
-fn aiur_fn_585(
-  inp: [G; IN_585],
+const INPUT_SIZE_490: usize = 2;
+const IN_490: usize = 2;
+const OUT_490: usize = 1;
+fn aiur_fn_490(
+  inp: [G; IN_490],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_585], ExecError> {
+) -> Result<[G; OUT_490], 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 __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_585] = [__v_0];
-        record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __v_12: G = G::from_u64(1);
+        let __ret: [G; OUT_490] = [__v_12];
+        record.function_queries[490].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __v_5: G = G::from_u64(4);
-        let __r_arr: [G; OUT_585] = { let __args: [G; IN_585] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[585].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_585] = unsafe { *(result.output.as_ptr() as *const [G; OUT_585]) }; __ret } else { aiur_fn_585(__args, record, io_buffer, __cu)? } };
-        let __v_6: G = __r_arr[0];
-        let __v_7: G = G::from_u64(0);
-        let __v_8: G = { let __values: [G; 4] = [__v_5, __v_3, __v_6, __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_585] = [__v_8];
-        record.function_queries[585].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_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: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
+        let __v_12: G = __loaded[0];
+        let __v_13: G = __loaded[1];
+        let __v_14: G = __loaded[2];
+        let __v_15: G = __loaded[3];
+        let __v_16: G = __loaded[4];
+        let __v_17: G = __loaded[5];
+        let __v_18: G = __loaded[6];
+        let __v_19: G = __loaded[7];
+        let __v_20: G = __loaded[8];
+        let __v_21: G = __loaded[9];
+        match __v_12.as_canonical_u64() {
+          0u64 => {
+            let __r_arr: [G; OUT_490] = { let __args: [G; IN_490] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[490].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_490] = unsafe { *(result.output.as_ptr() as *const [G; OUT_490]) }; __ret } else { aiur_fn_490(__args, record, io_buffer, __cu)? } };
+            let __v_22: G = __r_arr[0];
+            let __r_arr: [G; OUT_491] = { let __args: [G; IN_491] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[491].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_491] = unsafe { *(result.output.as_ptr() as *const [G; OUT_491]) }; __ret } else { aiur_fn_491(__args, record, io_buffer, __cu)? } };
+            let __v_23: G = __r_arr[0];
+            let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[476].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_476] = unsafe { *(result.output.as_ptr() as *const [G; OUT_476]) }; __ret } else { aiur_fn_476(__args, record, io_buffer, __cu)? } };
+            let __v_24: G = __r_arr[0];
+            let __ret: [G; OUT_490] = [__v_24];
+            record.function_queries[490].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()));
@@ -50101,15 +41511,15 @@ fn aiur_fn_585(
   })
 }
 
-const INPUT_SIZE_586: usize = 15;
-const IN_586: usize = 15;
-const OUT_586: usize = 1;
-fn aiur_fn_586(
-  inp: [G; IN_586],
+const INPUT_SIZE_491: usize = 16;
+const IN_491: usize = 16;
+const OUT_491: usize = 1;
+fn aiur_fn_491(
+  inp: [G; IN_491],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_586], ExecError> {
+) -> Result<[G; OUT_491], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -50126,119 +41536,169 @@ fn aiur_fn_586(
     let __v_12: G = inp[12];
     let __v_13: G = inp[13];
     let __v_14: G = inp[14];
-    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_15: G = __loaded[0];
-    let __v_16: G = __loaded[1];
-    let __v_17: G = __loaded[2];
-    match __v_15.as_canonical_u64() {
+    let __v_15: G = inp[15];
+    let __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_7, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[475].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_475] = unsafe { *(result.output.as_ptr() as *const [G; OUT_475]) }; __ret } else { aiur_fn_475(__args, record, io_buffer, __cu)? } };
+    let __v_16: G = __r_arr[0];
+    let __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_6, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[475].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_475] = unsafe { *(result.output.as_ptr() as *const [G; OUT_475]) }; __ret } else { aiur_fn_475(__args, record, io_buffer, __cu)? } };
+    let __v_17: G = __r_arr[0];
+    let __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_5, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[475].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_475] = unsafe { *(result.output.as_ptr() as *const [G; OUT_475]) }; __ret } else { aiur_fn_475(__args, record, io_buffer, __cu)? } };
+    let __v_18: G = __r_arr[0];
+    let __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_4, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[475].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_475] = unsafe { *(result.output.as_ptr() as *const [G; OUT_475]) }; __ret } else { aiur_fn_475(__args, record, io_buffer, __cu)? } };
+    let __v_19: G = __r_arr[0];
+    let __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_3, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[475].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_475] = unsafe { *(result.output.as_ptr() as *const [G; OUT_475]) }; __ret } else { aiur_fn_475(__args, record, io_buffer, __cu)? } };
+    let __v_20: G = __r_arr[0];
+    let __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_2, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[475].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_475] = unsafe { *(result.output.as_ptr() as *const [G; OUT_475]) }; __ret } else { aiur_fn_475(__args, record, io_buffer, __cu)? } };
+    let __v_21: G = __r_arr[0];
+    let __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[475].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_475] = unsafe { *(result.output.as_ptr() as *const [G; OUT_475]) }; __ret } else { aiur_fn_475(__args, record, io_buffer, __cu)? } };
+    let __v_22: G = __r_arr[0];
+    let __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[475].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_475] = unsafe { *(result.output.as_ptr() as *const [G; OUT_475]) }; __ret } else { aiur_fn_475(__args, record, io_buffer, __cu)? } };
+    let __v_23: G = __r_arr[0];
+    let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[476].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_476] = unsafe { *(result.output.as_ptr() as *const [G; OUT_476]) }; __ret } else { aiur_fn_476(__args, record, io_buffer, __cu)? } };
+    let __v_24: G = __r_arr[0];
+    let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_21, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[476].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_476] = unsafe { *(result.output.as_ptr() as *const [G; OUT_476]) }; __ret } else { aiur_fn_476(__args, record, io_buffer, __cu)? } };
+    let __v_25: G = __r_arr[0];
+    let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_20, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[476].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_476] = unsafe { *(result.output.as_ptr() as *const [G; OUT_476]) }; __ret } else { aiur_fn_476(__args, record, io_buffer, __cu)? } };
+    let __v_26: G = __r_arr[0];
+    let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_19, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[476].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_476] = unsafe { *(result.output.as_ptr() as *const [G; OUT_476]) }; __ret } else { aiur_fn_476(__args, record, io_buffer, __cu)? } };
+    let __v_27: G = __r_arr[0];
+    let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_18, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[476].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_476] = unsafe { *(result.output.as_ptr() as *const [G; OUT_476]) }; __ret } else { aiur_fn_476(__args, record, io_buffer, __cu)? } };
+    let __v_28: G = __r_arr[0];
+    let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_17, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[476].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_476] = unsafe { *(result.output.as_ptr() as *const [G; OUT_476]) }; __ret } else { aiur_fn_476(__args, record, io_buffer, __cu)? } };
+    let __v_29: G = __r_arr[0];
+    let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_16, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[476].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_476] = unsafe { *(result.output.as_ptr() as *const [G; OUT_476]) }; __ret } else { aiur_fn_476(__args, record, io_buffer, __cu)? } };
+    let __v_30: G = __r_arr[0];
+    let __ret: [G; OUT_491] = [__v_30];
+    record.function_queries[491].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_492: usize = 2;
+const IN_492: usize = 2;
+const OUT_492: usize = 1;
+fn aiur_fn_492(
+  inp: [G; IN_492],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_492], 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_586] = [__v_0];
-        record.function_queries[586].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_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_5: G = __loaded[0];
+        let __v_6: G = __loaded[1];
+        let __v_7: G = __loaded[2];
+        match __v_5.as_canonical_u64() {
+          1u64 => {
+            let __v_8: G = G::from_u64(1);
+            let __ret: [G; OUT_492] = [__v_8];
+            record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            let __v_8: G = G::from_u64(0);
+            let __ret: [G; OUT_492] = [__v_8];
+            record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+        }
       },
       0u64 => {
-        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_2, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-        let __v_18: G = __r_arr[0];
-        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_4, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-        let __v_19: G = __r_arr[0];
-        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_5, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-        let __v_20: G = __r_arr[0];
-        let __v_21: G = (__v_8 + __v_9);
-        let __v_22: G = (__v_7 + __v_21);
-        let __v_23: G = (__v_6 + __v_22);
-        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_3, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-        let __v_24: G = __r_arr[0];
-        let __v_25: G = (__v_9 - __v_16);
-        let __v_26: G = G::from_u64(0);
-        let __r_arr: [G; OUT_413] = { let __args: [G; IN_413] = [__v_24, __v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[413].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_413] = unsafe { *(result.output.as_ptr() as *const [G; OUT_413]) }; __ret } else { aiur_fn_413(__args, record, io_buffer, __cu)? } };
-        let __v_27: G = __r_arr[0];
-        let __v_28: G = (__v_7 + __v_8);
-        let __r_arr: [G; OUT_413] = { let __args: [G; IN_413] = [__v_27, __v_28, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[413].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_413] = unsafe { *(result.output.as_ptr() as *const [G; OUT_413]) }; __ret } else { aiur_fn_413(__args, record, io_buffer, __cu)? } };
-        let __v_29: G = __r_arr[0];
-        let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_29, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } };
-        let __v_30: G = __r_arr[0];
-        let __r_arr: [G; OUT_568] = { let __args: [G; IN_568] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[568].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_568] = unsafe { *(result.output.as_ptr() as *const [G; OUT_568]) }; __ret } else { aiur_fn_568(__args, record, io_buffer, __cu)? } };
-        let __v_31: G = __r_arr[0];
-        let __v_32: G = __r_arr[1];
-        let __r_arr: [G; OUT_776] = { let __args: [G; IN_776] = [__v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[776].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_776] = unsafe { *(result.output.as_ptr() as *const [G; OUT_776]) }; __ret } else { aiur_fn_776(__args, record, io_buffer, __cu)? } };
-        let __v_33: G = __r_arr[0];
-        let __r_arr: [G; OUT_773] = { let __args: [G; IN_773] = [__v_33, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[773].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_773] = unsafe { *(result.output.as_ptr() as *const [G; OUT_773]) }; __ret } else { aiur_fn_773(__args, record, io_buffer, __cu)? } };
-        let __v_34: G = __r_arr[0];
-        let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_32, __v_34, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } };
-        let __v_35: G = __r_arr[0];
-        let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { 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_36: G = __r_arr[0];
-        let __v_37: G = (__v_23 + __v_36);
-        let __v_38: G = G::from_u64(2);
-        let __v_39: G = G::from_u64(0);
-        let __v_40: G = { let __values: [G; 4] = [__v_38, __v_19, __v_10, __v_39]; 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_41: G = G::from_u64(1);
-        let __v_42: G = (__v_37 - __v_41);
-        let __v_43: G = G::from_u64(0);
-        let __r_arr: [G; OUT_571] = { let __args: [G; IN_571] = [__v_40, __v_6, __v_42, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[571].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_571] = unsafe { *(result.output.as_ptr() as *const [G; OUT_571]) }; __ret } else { aiur_fn_571(__args, record, io_buffer, __cu)? } };
-        let __v_44: G = __r_arr[0];
-        let __v_45: G = G::from_u64(1);
-        let __v_46: G = (__v_37 - __v_45);
-        let __v_47: G = (__v_46 - __v_6);
-        let __v_48: G = G::from_u64(0);
-        let __r_arr: [G; OUT_571] = { let __args: [G; IN_571] = [__v_44, __v_7, __v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[571].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_571] = unsafe { *(result.output.as_ptr() as *const [G; OUT_571]) }; __ret } else { aiur_fn_571(__args, record, io_buffer, __cu)? } };
-        let __v_49: G = __r_arr[0];
-        let __v_50: G = G::from_u64(1);
-        let __v_51: G = (__v_37 - __v_50);
-        let __v_52: G = (__v_51 - __v_6);
-        let __v_53: G = (__v_52 - __v_7);
-        let __v_54: G = G::from_u64(0);
-        let __r_arr: [G; OUT_571] = { let __args: [G; IN_571] = [__v_49, __v_8, __v_53, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[571].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_571] = unsafe { *(result.output.as_ptr() as *const [G; OUT_571]) }; __ret } else { aiur_fn_571(__args, record, io_buffer, __cu)? } };
-        let __v_55: G = __r_arr[0];
-        let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[189].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_189] = unsafe { *(result.output.as_ptr() as *const [G; OUT_189]) }; __ret } else { aiur_fn_189(__args, record, io_buffer, __cu)? } };
-        let __v_56: G = __r_arr[0];
-        let __v_57: G = __r_arr[1];
-        let __r_arr: [G; OUT_796] = { let __args: [G; IN_796] = [__v_57, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[796].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_796] = unsafe { *(result.output.as_ptr() as *const [G; OUT_796]) }; __ret } else { aiur_fn_796(__args, record, io_buffer, __cu)? } };
-        let __v_58: G = __r_arr[0];
-        let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_55, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[427].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_427] = unsafe { *(result.output.as_ptr() as *const [G; OUT_427]) }; __ret } else { aiur_fn_427(__args, record, io_buffer, __cu)? } };
-        let __v_59: G = __r_arr[0];
-        let __v_60: G = G::from_u64(1);
-        let __v_61: G = (__v_9 - __v_60);
-        let __v_62: G = (__v_61 - __v_16);
-        let __v_63: G = (__v_62 + __v_36);
-        let __v_64: G = G::from_u64(0);
-        let __v_65: G = G::from_u64(0);
-        let __v_66: G = { let __values: [G; 4] = [__v_64, __v_63, __v_65, __v_65]; 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_67: G = G::from_u64(0);
-        let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_66, __v_36, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[554].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_554] = unsafe { *(result.output.as_ptr() as *const [G; OUT_554]) }; __ret } else { aiur_fn_554(__args, record, io_buffer, __cu)? } };
-        let __v_68: G = __r_arr[0];
-        let __v_69: G = G::from_u64(3);
-        let __v_70: G = G::from_u64(0);
-        let __v_71: G = { let __values: [G; 4] = [__v_69, __v_59, __v_68, __v_70]; 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_585] = { let __args: [G; IN_585] = [__v_71, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[585].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_585] = unsafe { *(result.output.as_ptr() as *const [G; OUT_585]) }; __ret } else { aiur_fn_585(__args, record, io_buffer, __cu)? } };
-        let __v_72: G = __r_arr[0];
-        let __v_73: G = G::from_u64(3);
-        let __v_74: G = G::from_u64(0);
-        let __v_75: G = { let __values: [G; 4] = [__v_73, __v_0, __v_72, __v_74]; 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_76: G = G::from_u64(1);
-        let __v_77: G = (__v_14 + __v_76);
-        let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_75, __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_77]; let __cu = unconstrained; if let Some(result) = record.function_queries[586].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_586] = unsafe { *(result.output.as_ptr() as *const [G; OUT_586]) }; __ret } else { aiur_fn_586(__args, record, io_buffer, __cu)? } };
-        let __v_78: G = __r_arr[0];
-        let __ret: [G; OUT_586] = [__v_78];
-        record.function_queries[586].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_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_5: G = __loaded[0];
+        let __v_6: G = __loaded[1];
+        let __v_7: G = __loaded[2];
+        match __v_5.as_canonical_u64() {
+          1u64 => {
+            let __v_8: G = G::from_u64(2);
+            let __ret: [G; OUT_492] = [__v_8];
+            record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          0u64 => {
+            let __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[475].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_475] = unsafe { *(result.output.as_ptr() as *const [G; OUT_475]) }; __ret } else { aiur_fn_475(__args, record, io_buffer, __cu)? } };
+            let __v_8: G = __r_arr[0];
+            let __r_arr: [G; OUT_492] = { let __args: [G; IN_492] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[492].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_492] = unsafe { *(result.output.as_ptr() as *const [G; OUT_492]) }; __ret } else { aiur_fn_492(__args, record, io_buffer, __cu)? } };
+            let __v_9: G = __r_arr[0];
+            let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[476].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_476] = unsafe { *(result.output.as_ptr() as *const [G; OUT_476]) }; __ret } else { aiur_fn_476(__args, record, io_buffer, __cu)? } };
+            let __v_10: G = __r_arr[0];
+            let __ret: [G; OUT_492] = [__v_10];
+            record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_493: usize = 3;
+const IN_493: usize = 3;
+const OUT_493: usize = 2;
+fn aiur_fn_493(
+  inp: [G; IN_493],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_493], 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 = (__v_0 - __v_1);
+    match __v_3.as_canonical_u64() {
+      0u64 => {
+        let __r_arr: [G; OUT_478] = { let __args: [G; IN_478] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[478].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_478] = unsafe { *(result.output.as_ptr() as *const [G; OUT_478]) }; __ret } else { aiur_fn_478(__args, record, io_buffer, __cu)? } };
+        let __v_4: G = __r_arr[0];
+        let __v_5: G = __r_arr[1];
+        let __ret: [G; OUT_493] = [__v_4, __v_5];
+        record.function_queries[493].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_15.as_canonical_u64()));
+        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_4: G = __loaded[0];
+        let __v_5: G = __loaded[1];
+        let __v_6: G = __loaded[2];
+        let __v_7: G = __loaded[3];
+        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_8: G = __loaded[0];
+        let __v_9: G = __loaded[1];
+        let __v_10: G = __loaded[2];
+        let __v_11: G = __loaded[3];
+        let __r_arr: [G; OUT_494] = { let __args: [G; IN_494] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[494].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_494] = unsafe { *(result.output.as_ptr() as *const [G; OUT_494]) }; __ret } else { aiur_fn_494(__args, record, io_buffer, __cu)? } };
+        let __v_12: G = __r_arr[0];
+        let __v_13: G = __r_arr[1];
+        let __ret: [G; OUT_493] = [__v_12, __v_13];
+        record.function_queries[493].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_587: usize = 7;
-const IN_587: usize = 7;
-const OUT_587: usize = 1;
-fn aiur_fn_587(
-  inp: [G; IN_587],
+const INPUT_SIZE_494: usize = 9;
+const IN_494: usize = 9;
+const OUT_494: usize = 2;
+fn aiur_fn_494(
+  inp: [G; IN_494],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_587], ExecError> {
+) -> Result<[G; OUT_494], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -50247,145 +41707,439 @@ fn aiur_fn_587(
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
     let __v_6: G = inp[6];
-    let __v_7: G = (__v_4 + __v_5);
-    let __v_8: G = (__v_3 + __v_7);
-    let __v_9: G = (__v_2 + __v_8);
-    let __r_arr: [G; OUT_516] = { let __args: [G; IN_516] = [__v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[516].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_516] = unsafe { *(result.output.as_ptr() as *const [G; OUT_516]) }; __ret } else { aiur_fn_516(__args, record, io_buffer, __cu)? } };
-    let __v_10: 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_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: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].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];
-    match __v_11.as_canonical_u64() {
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        match __v_4.as_canonical_u64() {
+          0u64 => {
+            let __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[475].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_475] = unsafe { *(result.output.as_ptr() as *const [G; OUT_475]) }; __ret } else { aiur_fn_475(__args, record, io_buffer, __cu)? } };
+            let __v_9: G = __r_arr[0];
+            let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } };
+            let __v_10: G = __r_arr[0];
+            let __v_11: G = __r_arr[1];
+            let __ret: [G; OUT_494] = [__v_10, __v_11];
+            record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            let __r_arr: [G; OUT_477] = { let __args: [G; IN_477] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[477].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_477] = unsafe { *(result.output.as_ptr() as *const [G; OUT_477]) }; __ret } else { aiur_fn_477(__args, record, io_buffer, __cu)? } };
+            let __v_9: G = __r_arr[0];
+            let __v_10: G = __r_arr[1];
+            let __ret: [G; OUT_494] = [__v_9, __v_10];
+            record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+        }
+      },
+      1u64 => {
+        match __v_4.as_canonical_u64() {
+          0u64 => {
+            let __r_arr: [G; OUT_479] = { let __args: [G; IN_479] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[479].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_479] = unsafe { *(result.output.as_ptr() as *const [G; OUT_479]) }; __ret } else { aiur_fn_479(__args, record, io_buffer, __cu)? } };
+            let __v_9: G = __r_arr[0];
+            let __v_10: G = __r_arr[1];
+            let __ret: [G; OUT_494] = [__v_9, __v_10];
+            record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          1u64 => {
+            let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } };
+            let __v_9: G = __r_arr[0];
+            let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } };
+            let __v_10: G = __r_arr[0];
+            let __v_11: G = __r_arr[1];
+            let __ret: [G; OUT_494] = [__v_10, __v_11];
+            record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            let __r_arr: [G; OUT_477] = { let __args: [G; IN_477] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[477].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_477] = unsafe { *(result.output.as_ptr() as *const [G; OUT_477]) }; __ret } else { aiur_fn_477(__args, record, io_buffer, __cu)? } };
+            let __v_9: G = __r_arr[0];
+            let __v_10: G = __r_arr[1];
+            let __ret: [G; OUT_494] = [__v_9, __v_10];
+            record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+        }
+      },
+      2u64 => {
+        match __v_4.as_canonical_u64() {
+          0u64 => {
+            let __r_arr: [G; OUT_479] = { let __args: [G; IN_479] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[479].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_479] = unsafe { *(result.output.as_ptr() as *const [G; OUT_479]) }; __ret } else { aiur_fn_479(__args, record, io_buffer, __cu)? } };
+            let __v_9: G = __r_arr[0];
+            let __v_10: G = __r_arr[1];
+            let __ret: [G; OUT_494] = [__v_9, __v_10];
+            record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          1u64 => {
+            let __r_arr: [G; OUT_479] = { let __args: [G; IN_479] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[479].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_479] = unsafe { *(result.output.as_ptr() as *const [G; OUT_479]) }; __ret } else { aiur_fn_479(__args, record, io_buffer, __cu)? } };
+            let __v_9: G = __r_arr[0];
+            let __v_10: G = __r_arr[1];
+            let __ret: [G; OUT_494] = [__v_9, __v_10];
+            record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          2u64 => {
+            let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } };
+            let __v_9: G = __r_arr[0];
+            let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } };
+            let __v_10: G = __r_arr[0];
+            let __v_11: G = __r_arr[1];
+            let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } else { aiur_fn_485(__args, record, io_buffer, __cu)? } };
+            let __v_12: G = __r_arr[0];
+            let __v_13: G = __r_arr[1];
+            let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[480].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_480] = unsafe { *(result.output.as_ptr() as *const [G; OUT_480]) }; __ret } else { aiur_fn_480(__args, record, io_buffer, __cu)? } };
+            let __v_14: G = __r_arr[0];
+            let __v_15: G = __r_arr[1];
+            let __ret: [G; OUT_494] = [__v_14, __v_15];
+            record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            let __r_arr: [G; OUT_477] = { let __args: [G; IN_477] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[477].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_477] = unsafe { *(result.output.as_ptr() as *const [G; OUT_477]) }; __ret } else { aiur_fn_477(__args, record, io_buffer, __cu)? } };
+            let __v_9: G = __r_arr[0];
+            let __v_10: G = __r_arr[1];
+            let __ret: [G; OUT_494] = [__v_9, __v_10];
+            record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+        }
+      },
+      3u64 => {
+        match __v_4.as_canonical_u64() {
+          0u64 => {
+            let __r_arr: [G; OUT_479] = { let __args: [G; IN_479] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[479].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_479] = unsafe { *(result.output.as_ptr() as *const [G; OUT_479]) }; __ret } else { aiur_fn_479(__args, record, io_buffer, __cu)? } };
+            let __v_9: G = __r_arr[0];
+            let __v_10: G = __r_arr[1];
+            let __ret: [G; OUT_494] = [__v_9, __v_10];
+            record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          1u64 => {
+            let __r_arr: [G; OUT_479] = { let __args: [G; IN_479] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[479].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_479] = unsafe { *(result.output.as_ptr() as *const [G; OUT_479]) }; __ret } else { aiur_fn_479(__args, record, io_buffer, __cu)? } };
+            let __v_9: G = __r_arr[0];
+            let __v_10: G = __r_arr[1];
+            let __ret: [G; OUT_494] = [__v_9, __v_10];
+            record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          2u64 => {
+            let __r_arr: [G; OUT_479] = { let __args: [G; IN_479] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[479].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_479] = unsafe { *(result.output.as_ptr() as *const [G; OUT_479]) }; __ret } else { aiur_fn_479(__args, record, io_buffer, __cu)? } };
+            let __v_9: G = __r_arr[0];
+            let __v_10: G = __r_arr[1];
+            let __ret: [G; OUT_494] = [__v_9, __v_10];
+            record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          3u64 => {
+            let __r_arr: [G; OUT_493] = { let __args: [G; IN_493] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[493].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_493] = unsafe { *(result.output.as_ptr() as *const [G; OUT_493]) }; __ret } else { aiur_fn_493(__args, record, io_buffer, __cu)? } };
+            let __v_9: G = __r_arr[0];
+            let __v_10: G = __r_arr[1];
+            let __r_arr: [G; OUT_493] = { let __args: [G; IN_493] = [__v_2, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[493].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_493] = unsafe { *(result.output.as_ptr() as *const [G; OUT_493]) }; __ret } else { aiur_fn_493(__args, record, io_buffer, __cu)? } };
+            let __v_11: G = __r_arr[0];
+            let __v_12: G = __r_arr[1];
+            let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[480].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_480] = unsafe { *(result.output.as_ptr() as *const [G; OUT_480]) }; __ret } else { aiur_fn_480(__args, record, io_buffer, __cu)? } };
+            let __v_13: G = __r_arr[0];
+            let __v_14: G = __r_arr[1];
+            let __ret: [G; OUT_494] = [__v_13, __v_14];
+            record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            let __r_arr: [G; OUT_477] = { let __args: [G; IN_477] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[477].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_477] = unsafe { *(result.output.as_ptr() as *const [G; OUT_477]) }; __ret } else { aiur_fn_477(__args, record, io_buffer, __cu)? } };
+            let __v_9: G = __r_arr[0];
+            let __v_10: G = __r_arr[1];
+            let __ret: [G; OUT_494] = [__v_9, __v_10];
+            record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+        }
+      },
+      4u64 => {
+        match __v_4.as_canonical_u64() {
+          0u64 => {
+            let __r_arr: [G; OUT_479] = { let __args: [G; IN_479] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[479].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_479] = unsafe { *(result.output.as_ptr() as *const [G; OUT_479]) }; __ret } else { aiur_fn_479(__args, record, io_buffer, __cu)? } };
+            let __v_9: G = __r_arr[0];
+            let __v_10: G = __r_arr[1];
+            let __ret: [G; OUT_494] = [__v_9, __v_10];
+            record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          1u64 => {
+            let __r_arr: [G; OUT_479] = { let __args: [G; IN_479] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[479].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_479] = unsafe { *(result.output.as_ptr() as *const [G; OUT_479]) }; __ret } else { aiur_fn_479(__args, record, io_buffer, __cu)? } };
+            let __v_9: G = __r_arr[0];
+            let __v_10: G = __r_arr[1];
+            let __ret: [G; OUT_494] = [__v_9, __v_10];
+            record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          2u64 => {
+            let __r_arr: [G; OUT_479] = { let __args: [G; IN_479] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[479].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_479] = unsafe { *(result.output.as_ptr() as *const [G; OUT_479]) }; __ret } else { aiur_fn_479(__args, record, io_buffer, __cu)? } };
+            let __v_9: G = __r_arr[0];
+            let __v_10: G = __r_arr[1];
+            let __ret: [G; OUT_494] = [__v_9, __v_10];
+            record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          3u64 => {
+            let __r_arr: [G; OUT_479] = { let __args: [G; IN_479] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[479].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_479] = unsafe { *(result.output.as_ptr() as *const [G; OUT_479]) }; __ret } else { aiur_fn_479(__args, record, io_buffer, __cu)? } };
+            let __v_9: G = __r_arr[0];
+            let __v_10: G = __r_arr[1];
+            let __ret: [G; OUT_494] = [__v_9, __v_10];
+            record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          4u64 => {
+            let __r_arr: [G; OUT_493] = { let __args: [G; IN_493] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[493].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_493] = unsafe { *(result.output.as_ptr() as *const [G; OUT_493]) }; __ret } else { aiur_fn_493(__args, record, io_buffer, __cu)? } };
+            let __v_9: G = __r_arr[0];
+            let __v_10: G = __r_arr[1];
+            let __r_arr: [G; OUT_493] = { let __args: [G; IN_493] = [__v_2, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[493].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_493] = unsafe { *(result.output.as_ptr() as *const [G; OUT_493]) }; __ret } else { aiur_fn_493(__args, record, io_buffer, __cu)? } };
+            let __v_11: G = __r_arr[0];
+            let __v_12: G = __r_arr[1];
+            let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[480].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_480] = unsafe { *(result.output.as_ptr() as *const [G; OUT_480]) }; __ret } else { aiur_fn_480(__args, record, io_buffer, __cu)? } };
+            let __v_13: G = __r_arr[0];
+            let __v_14: G = __r_arr[1];
+            let __ret: [G; OUT_494] = [__v_13, __v_14];
+            record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            let __r_arr: [G; OUT_477] = { let __args: [G; IN_477] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[477].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_477] = unsafe { *(result.output.as_ptr() as *const [G; OUT_477]) }; __ret } else { aiur_fn_477(__args, record, io_buffer, __cu)? } };
+            let __v_9: G = __r_arr[0];
+            let __v_10: G = __r_arr[1];
+            let __ret: [G; OUT_494] = [__v_9, __v_10];
+            record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+        }
+      },
       5u64 => {
-        let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[189].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_189] = unsafe { *(result.output.as_ptr() as *const [G; OUT_189]) }; __ret } else { aiur_fn_189(__args, record, io_buffer, __cu)? } };
-        let __v_15: G = __r_arr[0];
-        let __v_16: G = __r_arr[1];
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; 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: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].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];
-        match __v_17.as_canonical_u64() {
+        match __v_4.as_canonical_u64() {
+          0u64 => {
+            let __r_arr: [G; OUT_479] = { let __args: [G; IN_479] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[479].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_479] = unsafe { *(result.output.as_ptr() as *const [G; OUT_479]) }; __ret } else { aiur_fn_479(__args, record, io_buffer, __cu)? } };
+            let __v_9: G = __r_arr[0];
+            let __v_10: G = __r_arr[1];
+            let __ret: [G; OUT_494] = [__v_9, __v_10];
+            record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          1u64 => {
+            let __r_arr: [G; OUT_479] = { let __args: [G; IN_479] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[479].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_479] = unsafe { *(result.output.as_ptr() as *const [G; OUT_479]) }; __ret } else { aiur_fn_479(__args, record, io_buffer, __cu)? } };
+            let __v_9: G = __r_arr[0];
+            let __v_10: G = __r_arr[1];
+            let __ret: [G; OUT_494] = [__v_9, __v_10];
+            record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
           2u64 => {
-            let __ret: [G; OUT_587] = [__v_18];
-            record.function_queries[587].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __r_arr: [G; OUT_479] = { let __args: [G; IN_479] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[479].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_479] = unsafe { *(result.output.as_ptr() as *const [G; OUT_479]) }; __ret } else { aiur_fn_479(__args, record, io_buffer, __cu)? } };
+            let __v_9: G = __r_arr[0];
+            let __v_10: G = __r_arr[1];
+            let __ret: [G; OUT_494] = [__v_9, __v_10];
+            record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          3u64 => {
+            let __r_arr: [G; OUT_479] = { let __args: [G; IN_479] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[479].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_479] = unsafe { *(result.output.as_ptr() as *const [G; OUT_479]) }; __ret } else { aiur_fn_479(__args, record, io_buffer, __cu)? } };
+            let __v_9: G = __r_arr[0];
+            let __v_10: G = __r_arr[1];
+            let __ret: [G; OUT_494] = [__v_9, __v_10];
+            record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          4u64 => {
+            let __r_arr: [G; OUT_479] = { let __args: [G; IN_479] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[479].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_479] = unsafe { *(result.output.as_ptr() as *const [G; OUT_479]) }; __ret } else { aiur_fn_479(__args, record, io_buffer, __cu)? } };
+            let __v_9: G = __r_arr[0];
+            let __v_10: G = __r_arr[1];
+            let __ret: [G; OUT_494] = [__v_9, __v_10];
+            record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          5u64 => {
+            let __r_arr: [G; OUT_493] = { let __args: [G; IN_493] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[493].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_493] = unsafe { *(result.output.as_ptr() as *const [G; OUT_493]) }; __ret } else { aiur_fn_493(__args, record, io_buffer, __cu)? } };
+            let __v_9: G = __r_arr[0];
+            let __v_10: G = __r_arr[1];
+            let __r_arr: [G; OUT_493] = { let __args: [G; IN_493] = [__v_2, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[493].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_493] = unsafe { *(result.output.as_ptr() as *const [G; OUT_493]) }; __ret } else { aiur_fn_493(__args, record, io_buffer, __cu)? } };
+            let __v_11: G = __r_arr[0];
+            let __v_12: G = __r_arr[1];
+            let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[480].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_480] = unsafe { *(result.output.as_ptr() as *const [G; OUT_480]) }; __ret } else { aiur_fn_480(__args, record, io_buffer, __cu)? } };
+            let __v_13: G = __r_arr[0];
+            let __v_14: G = __r_arr[1];
+            let __ret: [G; OUT_494] = [__v_13, __v_14];
+            record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_17.as_canonical_u64()));
+            let __r_arr: [G; OUT_477] = { let __args: [G; IN_477] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[477].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_477] = unsafe { *(result.output.as_ptr() as *const [G; OUT_477]) }; __ret } else { aiur_fn_477(__args, record, io_buffer, __cu)? } };
+            let __v_9: G = __r_arr[0];
+            let __v_10: G = __r_arr[1];
+            let __ret: [G; OUT_494] = [__v_9, __v_10];
+            record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_588: usize = 6;
-const IN_588: usize = 6;
-const OUT_588: usize = 1;
-fn aiur_fn_588(
-  inp: [G; IN_588],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_588], 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 = (__v_1 + __v_2);
-    let __v_7: G = (__v_6 + __v_3);
-    let __v_8: G = (__v_7 + __v_4);
-    let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } else { aiur_fn_524(__args, record, io_buffer, __cu)? } };
-    let __v_9: 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_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: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].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];
-    match __v_10.as_canonical_u64() {
-      5u64 => {
-        let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[189].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_189] = unsafe { *(result.output.as_ptr() as *const [G; OUT_189]) }; __ret } else { aiur_fn_189(__args, record, io_buffer, __cu)? } };
-        let __v_14: G = __r_arr[0];
-        let __v_15: G = __r_arr[1];
-        let __r_arr: [G; OUT_792] = { let __args: [G; IN_792] = [__v_15, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[792].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_792] = unsafe { *(result.output.as_ptr() as *const [G; OUT_792]) }; __ret } else { aiur_fn_792(__args, record, io_buffer, __cu)? } };
-        let __v_16: G = __r_arr[0];
-        let __v_17: G = (__v_2 + __v_3);
-        let __v_18: G = (__v_17 + __v_4);
-        let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_16, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = unsafe { *(result.output.as_ptr() as *const [G; OUT_645]) }; __ret } else { aiur_fn_645(__args, record, io_buffer, __cu)? } };
-        let __v_19: G = __r_arr[0];
-        let __ret: [G; OUT_588] = [__v_19];
-        record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
+      6u64 => {
+        match __v_4.as_canonical_u64() {
+          0u64 => {
+            let __r_arr: [G; OUT_479] = { let __args: [G; IN_479] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[479].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_479] = unsafe { *(result.output.as_ptr() as *const [G; OUT_479]) }; __ret } else { aiur_fn_479(__args, record, io_buffer, __cu)? } };
+            let __v_9: G = __r_arr[0];
+            let __v_10: G = __r_arr[1];
+            let __ret: [G; OUT_494] = [__v_9, __v_10];
+            record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          1u64 => {
+            let __r_arr: [G; OUT_479] = { let __args: [G; IN_479] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[479].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_479] = unsafe { *(result.output.as_ptr() as *const [G; OUT_479]) }; __ret } else { aiur_fn_479(__args, record, io_buffer, __cu)? } };
+            let __v_9: G = __r_arr[0];
+            let __v_10: G = __r_arr[1];
+            let __ret: [G; OUT_494] = [__v_9, __v_10];
+            record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          2u64 => {
+            let __r_arr: [G; OUT_479] = { let __args: [G; IN_479] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[479].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_479] = unsafe { *(result.output.as_ptr() as *const [G; OUT_479]) }; __ret } else { aiur_fn_479(__args, record, io_buffer, __cu)? } };
+            let __v_9: G = __r_arr[0];
+            let __v_10: G = __r_arr[1];
+            let __ret: [G; OUT_494] = [__v_9, __v_10];
+            record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          3u64 => {
+            let __r_arr: [G; OUT_479] = { let __args: [G; IN_479] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[479].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_479] = unsafe { *(result.output.as_ptr() as *const [G; OUT_479]) }; __ret } else { aiur_fn_479(__args, record, io_buffer, __cu)? } };
+            let __v_9: G = __r_arr[0];
+            let __v_10: G = __r_arr[1];
+            let __ret: [G; OUT_494] = [__v_9, __v_10];
+            record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          4u64 => {
+            let __r_arr: [G; OUT_479] = { let __args: [G; IN_479] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[479].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_479] = unsafe { *(result.output.as_ptr() as *const [G; OUT_479]) }; __ret } else { aiur_fn_479(__args, record, io_buffer, __cu)? } };
+            let __v_9: G = __r_arr[0];
+            let __v_10: G = __r_arr[1];
+            let __ret: [G; OUT_494] = [__v_9, __v_10];
+            record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          5u64 => {
+            let __r_arr: [G; OUT_479] = { let __args: [G; IN_479] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[479].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_479] = unsafe { *(result.output.as_ptr() as *const [G; OUT_479]) }; __ret } else { aiur_fn_479(__args, record, io_buffer, __cu)? } };
+            let __v_9: G = __r_arr[0];
+            let __v_10: G = __r_arr[1];
+            let __ret: [G; OUT_494] = [__v_9, __v_10];
+            record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          6u64 => {
+            let __r_arr: [G; OUT_493] = { let __args: [G; IN_493] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[493].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_493] = unsafe { *(result.output.as_ptr() as *const [G; OUT_493]) }; __ret } else { aiur_fn_493(__args, record, io_buffer, __cu)? } };
+            let __v_9: G = __r_arr[0];
+            let __v_10: G = __r_arr[1];
+            let __r_arr: [G; OUT_493] = { let __args: [G; IN_493] = [__v_2, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[493].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_493] = unsafe { *(result.output.as_ptr() as *const [G; OUT_493]) }; __ret } else { aiur_fn_493(__args, record, io_buffer, __cu)? } };
+            let __v_11: G = __r_arr[0];
+            let __v_12: G = __r_arr[1];
+            let __r_arr: [G; OUT_493] = { let __args: [G; IN_493] = [__v_3, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[493].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_493] = unsafe { *(result.output.as_ptr() as *const [G; OUT_493]) }; __ret } else { aiur_fn_493(__args, record, io_buffer, __cu)? } };
+            let __v_13: G = __r_arr[0];
+            let __v_14: G = __r_arr[1];
+            let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[480].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_480] = unsafe { *(result.output.as_ptr() as *const [G; OUT_480]) }; __ret } else { aiur_fn_480(__args, record, io_buffer, __cu)? } };
+            let __v_15: G = __r_arr[0];
+            let __v_16: G = __r_arr[1];
+            let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_9, __v_10, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[480].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_480] = unsafe { *(result.output.as_ptr() as *const [G; OUT_480]) }; __ret } else { aiur_fn_480(__args, record, io_buffer, __cu)? } };
+            let __v_17: G = __r_arr[0];
+            let __v_18: G = __r_arr[1];
+            let __ret: [G; OUT_494] = [__v_17, __v_18];
+            record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            let __r_arr: [G; OUT_477] = { let __args: [G; IN_477] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[477].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_477] = unsafe { *(result.output.as_ptr() as *const [G; OUT_477]) }; __ret } else { aiur_fn_477(__args, record, io_buffer, __cu)? } };
+            let __v_9: G = __r_arr[0];
+            let __v_10: G = __r_arr[1];
+            let __ret: [G; OUT_494] = [__v_9, __v_10];
+            record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+        }
       },
-      _ => {
-        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 __ret: [G; OUT_588] = [__v_16];
-        record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
+      7u64 => {
+        match __v_4.as_canonical_u64() {
+          8u64 => {
+            let __r_arr: [G; OUT_477] = { let __args: [G; IN_477] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[477].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_477] = unsafe { *(result.output.as_ptr() as *const [G; OUT_477]) }; __ret } else { aiur_fn_477(__args, record, io_buffer, __cu)? } };
+            let __v_9: G = __r_arr[0];
+            let __v_10: G = __r_arr[1];
+            let __ret: [G; OUT_494] = [__v_9, __v_10];
+            record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          7u64 => {
+            let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_1, __v_2, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[488].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_488] = unsafe { *(result.output.as_ptr() as *const [G; OUT_488]) }; __ret } else { aiur_fn_488(__args, record, io_buffer, __cu)? } };
+            let __v_9: G = __r_arr[0];
+            let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } };
+            let __v_10: G = __r_arr[0];
+            let __v_11: G = __r_arr[1];
+            let __ret: [G; OUT_494] = [__v_10, __v_11];
+            record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            let __r_arr: [G; OUT_479] = { let __args: [G; IN_479] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[479].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_479] = unsafe { *(result.output.as_ptr() as *const [G; OUT_479]) }; __ret } else { aiur_fn_479(__args, record, io_buffer, __cu)? } };
+            let __v_9: G = __r_arr[0];
+            let __v_10: G = __r_arr[1];
+            let __ret: [G; OUT_494] = [__v_9, __v_10];
+            record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+        }
       },
-    }
-  })
-}
-
-const INPUT_SIZE_589: usize = 6;
-const IN_589: usize = 6;
-const OUT_589: usize = 1;
-fn aiur_fn_589(
-  inp: [G; IN_589],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_589], 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(0);
-    let __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_6, __v_5, __v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[590].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_590] = unsafe { *(result.output.as_ptr() as *const [G; OUT_590]) }; __ret } else { aiur_fn_590(__args, record, io_buffer, __cu)? } };
-    let __v_8: G = __r_arr[0];
-    match __v_8.as_canonical_u64() {
-      0u64 => {
-        let __v_9: G = G::from_u64(0);
-        let __v_10: G = G::from_u64(0);
-        let __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_9, __v_5, __v_5, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[590].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_590] = unsafe { *(result.output.as_ptr() as *const [G; OUT_590]) }; __ret } else { aiur_fn_590(__args, record, io_buffer, __cu)? } };
-        let __v_11: G = __r_arr[0];
-        let __ret: [G; OUT_589] = [__v_11];
-        record.function_queries[589].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
+      8u64 => {
+        match __v_4.as_canonical_u64() {
+          8u64 => {
+            let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } else { aiur_fn_485(__args, record, io_buffer, __cu)? } };
+            let __v_9: G = __r_arr[0];
+            let __v_10: G = __r_arr[1];
+            let __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[475].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_475] = unsafe { *(result.output.as_ptr() as *const [G; OUT_475]) }; __ret } else { aiur_fn_475(__args, record, io_buffer, __cu)? } };
+            let __v_11: G = __r_arr[0];
+            let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } };
+            let __v_12: G = __r_arr[0];
+            let __v_13: G = __r_arr[1];
+            let __r_arr: [G; OUT_493] = { let __args: [G; IN_493] = [__v_3, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[493].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_493] = unsafe { *(result.output.as_ptr() as *const [G; OUT_493]) }; __ret } else { aiur_fn_493(__args, record, io_buffer, __cu)? } };
+            let __v_14: G = __r_arr[0];
+            let __v_15: G = __r_arr[1];
+            let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[480].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_480] = unsafe { *(result.output.as_ptr() as *const [G; OUT_480]) }; __ret } else { aiur_fn_480(__args, record, io_buffer, __cu)? } };
+            let __v_16: G = __r_arr[0];
+            let __v_17: G = __r_arr[1];
+            let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_9, __v_10, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[480].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_480] = unsafe { *(result.output.as_ptr() as *const [G; OUT_480]) }; __ret } else { aiur_fn_480(__args, record, io_buffer, __cu)? } };
+            let __v_18: G = __r_arr[0];
+            let __v_19: G = __r_arr[1];
+            let __ret: [G; OUT_494] = [__v_18, __v_19];
+            record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            let __r_arr: [G; OUT_479] = { let __args: [G; IN_479] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[479].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_479] = unsafe { *(result.output.as_ptr() as *const [G; OUT_479]) }; __ret } else { aiur_fn_479(__args, record, io_buffer, __cu)? } };
+            let __v_9: G = __r_arr[0];
+            let __v_10: G = __r_arr[1];
+            let __ret: [G; OUT_494] = [__v_9, __v_10];
+            record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+        }
       },
       _ => {
-        let __ret: [G; OUT_589] = [__v_8];
-        record.function_queries[589].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
+        return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_590: usize = 9;
-const IN_590: usize = 9;
-const OUT_590: usize = 1;
-fn aiur_fn_590(
-  inp: [G; IN_590],
+const INPUT_SIZE_495: usize = 7;
+const IN_495: usize = 7;
+const OUT_495: usize = 2;
+fn aiur_fn_495(
+  inp: [G; IN_495],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_590], ExecError> {
+) -> Result<[G; OUT_495], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -50394,336 +42148,128 @@ fn aiur_fn_590(
     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; 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_9: G = __loaded[0];
-    let __v_10: G = __loaded[1];
-    let __v_11: G = __loaded[2];
-    match __v_9.as_canonical_u64() {
-      1u64 => {
-        let __v_12: G = G::from_u64(0);
-        let __ret: [G; OUT_590] = [__v_12];
-        record.function_queries[590].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr };
-        let __v_12: G = __loaded[0];
-        let __v_13: G = __loaded[1];
-        let __v_14: G = __loaded[2];
-        let __v_15: G = __loaded[3];
-        let __v_16: G = __loaded[4];
-        let __v_17: G = __loaded[5];
-        let __v_18: G = __loaded[6];
-        let __v_19: G = __loaded[7];
-        let __v_20: G = __loaded[8];
-        let __v_21: G = __loaded[9];
-        let __v_22: G = __loaded[10];
-        match __v_12.as_canonical_u64() {
-          7u64 => {
-            let __r_arr: [G; OUT_587] = { let __args: [G; IN_587] = [__v_19, __v_14, __v_15, __v_17, __v_18, __v_16, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[587].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_587] = unsafe { *(result.output.as_ptr() as *const [G; OUT_587]) }; __ret } else { aiur_fn_587(__args, record, io_buffer, __cu)? } };
-            let __v_23: G = __r_arr[0];
-            let __v_24: G = (__v_23 - __v_0);
-            let __v_25: G = G::from_bool((__v_24 == G::ZERO));
-            let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_5.as_canonical_u64() {
-  0u64 => {
-    let __v_26: G = G::from_u64(1);
-    break '__mc_0 [__v_26];
-  },
-  _ => {
-    let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_22, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_26: G = __r_arr[0];
-    break '__mc_0 [__v_26];
-  },
-}
- };
-            let __v_26: G = __mc_out___mc_0[0];
-            let __v_27: G = (__v_25 * __v_26);
-            match __v_27.as_canonical_u64() {
-              1u64 => {
-                let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_1.as_canonical_u64() {
-  0u64 => {
-    let __v_28: G = G::from_u64(1);
-    break '__mc_1 [__v_28];
-  },
-  _ => {
-    let __r_arr: [G; OUT_588] = { let __args: [G; IN_588] = [__v_14, __v_15, __v_17, __v_18, __v_16, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[588].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_588] = unsafe { *(result.output.as_ptr() as *const [G; OUT_588]) }; __ret } else { aiur_fn_588(__args, record, io_buffer, __cu)? } };
-    let __v_28: G = __r_arr[0];
-    let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_28, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = unsafe { *(result.output.as_ptr() as *const [G; OUT_606]) }; __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } };
-    let __v_29: G = __r_arr[0];
-    break '__mc_1 [__v_29];
-  },
-}
- };
-                let __v_28: G = __mc_out___mc_1[0];
-                match __v_28.as_canonical_u64() {
-                  1u64 => {
-                    let __ret: [G; OUT_590] = [__v_8];
-                    record.function_queries[590].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
-                  0u64 => {
-                    let __v_29: G = G::from_u64(1);
-                    let __v_30: G = (__v_8 + __v_29);
-                    let __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_11, __v_7, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[590].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_590] = unsafe { *(result.output.as_ptr() as *const [G; OUT_590]) }; __ret } else { aiur_fn_590(__args, record, io_buffer, __cu)? } };
-                    let __v_31: G = __r_arr[0];
-                    let __ret: [G; OUT_590] = [__v_31];
-                    record.function_queries[590].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
-                  _ => {
-                    return Err(ExecError::MatchNoCase(__v_28.as_canonical_u64()));
-                  },
-                }
-              },
-              0u64 => {
-                let __v_28: G = G::from_u64(1);
-                let __v_29: G = (__v_8 + __v_28);
-                let __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_11, __v_7, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[590].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_590] = unsafe { *(result.output.as_ptr() as *const [G; OUT_590]) }; __ret } else { aiur_fn_590(__args, record, io_buffer, __cu)? } };
-                let __v_30: G = __r_arr[0];
-                let __ret: [G; OUT_590] = [__v_30];
-                record.function_queries[590].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              _ => {
-                return Err(ExecError::MatchNoCase(__v_27.as_canonical_u64()));
-              },
-            }
-          },
+    match __v_0.as_canonical_u64() {
+      _ => {
+        match __v_3.as_canonical_u64() {
           _ => {
-            let __v_23: G = G::from_u64(1);
-            let __v_24: G = (__v_8 + __v_23);
-            let __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_11, __v_7, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[590].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_590] = unsafe { *(result.output.as_ptr() as *const [G; OUT_590]) }; __ret } else { aiur_fn_590(__args, record, io_buffer, __cu)? } };
-            let __v_25: G = __r_arr[0];
-            let __ret: [G; OUT_590] = [__v_25];
-            record.function_queries[590].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[475].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_475] = unsafe { *(result.output.as_ptr() as *const [G; OUT_475]) }; __ret } else { aiur_fn_475(__args, record, io_buffer, __cu)? } };
+            let __v_7: G = __r_arr[0];
+            let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } };
+            let __v_8: G = __r_arr[0];
+            let __v_9: G = __r_arr[1];
+            let __r_arr: [G; OUT_493] = { let __args: [G; IN_493] = [__v_2, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[493].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_493] = unsafe { *(result.output.as_ptr() as *const [G; OUT_493]) }; __ret } else { aiur_fn_493(__args, record, io_buffer, __cu)? } };
+            let __v_10: G = __r_arr[0];
+            let __v_11: G = __r_arr[1];
+            let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[480].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_480] = unsafe { *(result.output.as_ptr() as *const [G; OUT_480]) }; __ret } else { aiur_fn_480(__args, record, io_buffer, __cu)? } };
+            let __v_12: G = __r_arr[0];
+            let __v_13: G = __r_arr[1];
+            let __ret: [G; OUT_495] = [__v_12, __v_13];
+            record.function_queries[495].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64()));
-      },
     }
   })
 }
 
-const INPUT_SIZE_591: usize = 3;
-const IN_591: usize = 3;
-const OUT_591: usize = 1;
-fn aiur_fn_591(
-  inp: [G; IN_591],
+const INPUT_SIZE_496: usize = 3;
+const IN_496: usize = 3;
+const OUT_496: usize = 2;
+fn aiur_fn_496(
+  inp: [G; IN_496],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_591], ExecError> {
+) -> Result<[G; OUT_496], 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; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; 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: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
+    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 };
     let __v_3: G = __loaded[0];
     let __v_4: G = __loaded[1];
     let __v_5: G = __loaded[2];
     let __v_6: G = __loaded[3];
     let __v_7: G = __loaded[4];
-    let __v_8: G = __loaded[5];
-    match __v_3.as_canonical_u64() {
-      1u64 => {
-        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 __ret: [G; OUT_591] = [__v_11];
-        record.function_queries[591].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-        let __v_9: G = __r_arr[0];
-        let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].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 __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_10.as_canonical_u64() {
-  5u64 => {
-    break '__mc_0 [__v_13];
-  },
-  _ => {
-    let __v_21: G = G::from_u64(0);
-    break '__mc_0 [__v_21];
-  },
-}
- };
-        let __v_21: G = __mc_out___mc_0[0];
-        let __v_22: G = G::from_u64(0);
-        let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_4, __v_5, __v_6, __v_21, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[589].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_589] = unsafe { *(result.output.as_ptr() as *const [G; OUT_589]) }; __ret } else { aiur_fn_589(__args, record, io_buffer, __cu)? } };
-        let __v_23: G = __r_arr[0];
-        let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[591].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_591] = unsafe { *(result.output.as_ptr() as *const [G; OUT_591]) }; __ret } else { aiur_fn_591(__args, record, io_buffer, __cu)? } };
-        let __v_24: G = __r_arr[0];
-        let __v_25: G = { let __values: [G; 3] = [__v_22, __v_23, __v_24]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_591] = [__v_25];
-        record.function_queries[591].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_592: usize = 3;
-const IN_592: usize = 3;
-const OUT_592: usize = 1;
-fn aiur_fn_592(
-  inp: [G; IN_592],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_592], 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_592] = [__v_8];
-        record.function_queries[592].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __r_arr: [G; OUT_413] = { let __args: [G; IN_413] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[413].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_413] = unsafe { *(result.output.as_ptr() as *const [G; OUT_413]) }; __ret } else { aiur_fn_413(__args, record, io_buffer, __cu)? } };
-        let __v_6: G = __r_arr[0];
-        let __v_7: G = G::from_u64(0);
-        let __v_8: G = G::from_u64(1);
-        let __v_9: G = (__v_2 + __v_8);
-        let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_5, __v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } };
-        let __v_10: G = __r_arr[0];
-        let __v_11: G = { let __values: [G; 3] = [__v_7, __v_6, __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 __ret: [G; OUT_592] = [__v_11];
-        record.function_queries[592].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_593: usize = 4;
-const IN_593: usize = 4;
-const OUT_593: usize = 0;
-fn aiur_fn_593(
-  inp: [G; IN_593],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_593], 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; 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 };
-    let __v_4: G = __loaded[0];
-    let __v_5: G = __loaded[1];
-    let __v_6: G = __loaded[2];
-    let __v_7: G = __loaded[3];
-    let __v_8: G = __loaded[4];
-    match __v_4.as_canonical_u64() {
       1u64 => {
         let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; 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: 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() {
+        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];
+        match __v_8.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_593] = [];
-            record.function_queries[593].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __r_arr: [G; OUT_478] = { let __args: [G; IN_478] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[478].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_478] = unsafe { *(result.output.as_ptr() as *const [G; OUT_478]) }; __ret } else { aiur_fn_478(__args, record, io_buffer, __cu)? } };
+            let __v_13: G = __r_arr[0];
+            let __v_14: G = __r_arr[1];
+            let __ret: [G; OUT_496] = [__v_13, __v_14];
+            record.function_queries[496].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64()));
+            let __r_arr: [G; OUT_477] = { let __args: [G; IN_477] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[477].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_477] = unsafe { *(result.output.as_ptr() as *const [G; OUT_477]) }; __ret } else { aiur_fn_477(__args, record, io_buffer, __cu)? } };
+            let __v_13: G = __r_arr[0];
+            let __v_14: G = __r_arr[1];
+            let __ret: [G; OUT_496] = [__v_13, __v_14];
+            record.function_queries[496].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
           },
         }
       },
       0u64 => {
         let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; 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: 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() {
+        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];
+        match __v_8.as_canonical_u64() {
+          1u64 => {
+            let __r_arr: [G; OUT_479] = { let __args: [G; IN_479] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[479].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_479] = unsafe { *(result.output.as_ptr() as *const [G; OUT_479]) }; __ret } else { aiur_fn_479(__args, record, io_buffer, __cu)? } };
+            let __v_13: G = __r_arr[0];
+            let __v_14: G = __r_arr[1];
+            let __ret: [G; OUT_496] = [__v_13, __v_14];
+            record.function_queries[496].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
           0u64 => {
-            match __v_5.as_canonical_u64() {
-              _ => {
-                match __v_10.as_canonical_u64() {
-                  _ => {
-                    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_481] = { let __args: [G; IN_481] = [__v_7, __v_12, __v_16, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } };
-                    let __v_17: G = __r_arr[0];
-                    if (__v_5 != __v_10) {
-                      return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_10.as_canonical_u64() });
-                    }
-                    if (__v_6 != __v_11) {
-                      return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_11.as_canonical_u64() });
-                    }
-                    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() });
-                    }
-                    let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_8, __v_13, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } };
-                    let __ret: [G; OUT_593] = [];
-                    record.function_queries[593].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
-                }
-              },
-            }
+            let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_4, __v_5, __v_6, __v_9, __v_10, __v_11, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } else { aiur_fn_495(__args, record, io_buffer, __cu)? } };
+            let __v_13: G = __r_arr[0];
+            let __v_14: G = __r_arr[1];
+            let __r_arr: [G; OUT_496] = { let __args: [G; IN_496] = [__v_7, __v_12, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[496].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_496] = unsafe { *(result.output.as_ptr() as *const [G; OUT_496]) }; __ret } else { aiur_fn_496(__args, record, io_buffer, __cu)? } };
+            let __v_15: G = __r_arr[0];
+            let __v_16: G = __r_arr[1];
+            let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[480].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_480] = unsafe { *(result.output.as_ptr() as *const [G; OUT_480]) }; __ret } else { aiur_fn_480(__args, record, io_buffer, __cu)? } };
+            let __v_17: G = __r_arr[0];
+            let __v_18: G = __r_arr[1];
+            let __ret: [G; OUT_496] = [__v_17, __v_18];
+            record.function_queries[496].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
           },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64()));
+            return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64()));
           },
         }
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
+        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_594: usize = 13;
-const IN_594: usize = 13;
-const OUT_594: usize = 0;
-fn aiur_fn_594(
-  inp: [G; IN_594],
+const INPUT_SIZE_497: usize = 12;
+const IN_497: usize = 12;
+const OUT_497: usize = 1;
+fn aiur_fn_497(
+  inp: [G; IN_497],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_594], ExecError> {
+) -> Result<[G; OUT_497], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -50737,540 +42283,795 @@ fn aiur_fn_594(
     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_1.as_canonical_u64() {
+    match __v_0.as_canonical_u64() {
+      1u64 => {
+        let __v_12: G = G::from_u64(0);
+        let __ret: [G; OUT_497] = [__v_12];
+        record.function_queries[497].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      2u64 => {
+        let __v_12: G = G::from_u64(0);
+        let __ret: [G; OUT_497] = [__v_12];
+        record.function_queries[497].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      3u64 => {
+        let __v_12: G = G::from_u64(0);
+        let __ret: [G; OUT_497] = [__v_12];
+        record.function_queries[497].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      5u64 => {
+        let __v_12: G = G::from_u64(1);
+        let __ret: [G; OUT_497] = [__v_12];
+        record.function_queries[497].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      7u64 => {
+        let __v_12: G = G::from_u64(2);
+        let __ret: [G; OUT_497] = [__v_12];
+        record.function_queries[497].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
       6u64 => {
-        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_12, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-        let __v_13: G = __r_arr[0];
-        let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].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];
-        let __v_18: G = __loaded[4];
-        let __v_19: G = __loaded[5];
-        let __v_20: G = __loaded[6];
-        let __v_21: G = __loaded[7];
-        let __v_22: G = __loaded[8];
-        let __v_23: G = __loaded[9];
-        let __v_24: G = __loaded[10];
-        match __v_14.as_canonical_u64() {
-          5u64 => {
-            let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_19, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-            let __v_25: G = __r_arr[0];
-            if (__v_25 != __v_0) {
-              return Err(ExecError::AssertEqMismatch { lhs: __v_25.as_canonical_u64(), rhs: __v_0.as_canonical_u64() });
-            }
-            let __ret: [G; OUT_594] = [];
-            record.function_queries[594].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64()));
-          },
-        }
+        let __v_12: G = G::from_u64(3);
+        let __ret: [G; OUT_497] = [__v_12];
+        record.function_queries[497].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __v_12: G = G::from_u64(4);
+        let __ret: [G; OUT_497] = [__v_12];
+        record.function_queries[497].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      4u64 => {
+        let __v_12: G = G::from_u64(5);
+        let __ret: [G; OUT_497] = [__v_12];
+        record.function_queries[497].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+        return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_595: usize = 3;
-const IN_595: usize = 3;
-const OUT_595: usize = 1;
-fn aiur_fn_595(
-  inp: [G; IN_595],
+const INPUT_SIZE_498: usize = 25;
+const IN_498: usize = 25;
+const OUT_498: usize = 2;
+fn aiur_fn_498(
+  inp: [G; IN_498],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_595], ExecError> {
+) -> Result<[G; OUT_498], 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_778] = { let __args: [G; IN_778] = [__v_1, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-    let __v_3: G = __r_arr[0];
-    let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr };
-    let __v_4: G = __loaded[0];
-    let __v_5: G = __loaded[1];
-    let __v_6: G = __loaded[2];
-    let __v_7: G = __loaded[3];
-    let __v_8: G = __loaded[4];
-    let __v_9: G = __loaded[5];
-    let __v_10: G = __loaded[6];
-    let __v_11: G = __loaded[7];
-    let __v_12: G = __loaded[8];
-    let __v_13: G = __loaded[9];
-    let __v_14: G = __loaded[10];
-    match __v_4.as_canonical_u64() {
-      5u64 => {
-        let __r_arr: [G; OUT_559] = { let __args: [G; IN_559] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[559].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_559] = unsafe { *(result.output.as_ptr() as *const [G; OUT_559]) }; __ret } else { aiur_fn_559(__args, record, io_buffer, __cu)? } };
-        let __v_15: G = __r_arr[0];
-        let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { 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_16: G = __r_arr[0];
-        let __v_17: G = G::from_u64(1);
-        let __v_18: G = (__v_16 - __v_17);
-        match __v_18.as_canonical_u64() {
-          0u64 => {
-            let __v_19: G = (__v_7 + __v_8);
-            let __v_20: G = G::from_u64(1);
-            let __v_21: G = G::from_u64(1);
-            let __v_22: G = { let __values: [G; 3] = [__v_20, __v_21, __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 __r_arr: [G; OUT_519] = { let __args: [G; IN_519] = [__v_6, __v_19, __v_22, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[519].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_519] = unsafe { *(result.output.as_ptr() as *const [G; OUT_519]) }; __ret } else { aiur_fn_519(__args, record, io_buffer, __cu)? } };
-            let __v_23: G = __r_arr[0];
-            let __v_24: G = G::from_u64(0);
-            let __v_25: G = G::from_u64(0);
-            let __v_26: G = { let __values: [G; 3] = [__v_24, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_216] = { let __args: [G; IN_216] = [__v_23, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[216].get_mut(&__args[..]) { 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_27: G = __r_arr[0];
-            match __v_27.as_canonical_u64() {
-              0u64 => {
-                let __v_28: G = G::from_u64(0);
-                let __ret: [G; OUT_595] = [__v_28];
-                record.function_queries[595].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              1u64 => {
-                let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { 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_28: G = __r_arr[0];
-                let __v_29: G = G::from_u64(1);
-                let __v_30: G = (__v_28 - __v_29);
-                match __v_30.as_canonical_u64() {
-                  0u64 => {
-                    let __v_31: G = G::from_u64(0);
-                    let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_9, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-                    let __v_32: G = __r_arr[0];
-                    let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_1, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-                    let __v_33: G = __r_arr[0];
-                    let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].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];
-                    match __v_34.as_canonical_u64() {
-                      6u64 => {
-                        let __v_45: G = G::from_bool((__v_40 == G::ZERO));
-                        let __ret: [G; OUT_595] = [__v_45];
-                        record.function_queries[595].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                        return Ok(__ret);
-                      },
-                      _ => {
-                        let __v_45: G = G::from_u64(0);
-                        let __ret: [G; OUT_595] = [__v_45];
-                        record.function_queries[595].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                        return Ok(__ret);
-                      },
-                    }
-                  },
-                  _ => {
-                    let __v_31: G = G::from_u64(0);
-                    let __ret: [G; OUT_595] = [__v_31];
-                    record.function_queries[595].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
-                }
-              },
-              _ => {
-                return Err(ExecError::MatchNoCase(__v_27.as_canonical_u64()));
-              },
-            }
-          },
-          _ => {
-            let __v_19: G = G::from_u64(0);
-            let __ret: [G; OUT_595] = [__v_19];
-            record.function_queries[595].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-        }
+    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 __r_arr: [G; OUT_497] = { let __args: [G; IN_497] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[497].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_497] = unsafe { *(result.output.as_ptr() as *const [G; OUT_497]) }; __ret } else { aiur_fn_497(__args, record, io_buffer, __cu)? } };
+    let __v_25: G = __r_arr[0];
+    let __r_arr: [G; OUT_497] = { let __args: [G; IN_497] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[497].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_497] = unsafe { *(result.output.as_ptr() as *const [G; OUT_497]) }; __ret } else { aiur_fn_497(__args, record, io_buffer, __cu)? } };
+    let __v_26: G = __r_arr[0];
+    let __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[475].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_475] = unsafe { *(result.output.as_ptr() as *const [G; OUT_475]) }; __ret } else { aiur_fn_475(__args, record, io_buffer, __cu)? } };
+    let __v_27: G = __r_arr[0];
+    match __v_27.as_canonical_u64() {
+      1u64 => {
+        let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__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]; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } else { aiur_fn_499(__args, record, io_buffer, __cu)? } };
+        let __v_28: G = __r_arr[0];
+        let __v_29: G = __r_arr[1];
+        let __ret: [G; OUT_498] = [__v_28, __v_29];
+        record.function_queries[498].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
       _ => {
-        let __v_15: G = G::from_u64(0);
-        let __ret: [G; OUT_595] = [__v_15];
-        record.function_queries[595].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } };
+        let __v_28: G = __r_arr[0];
+        let __v_29: G = __r_arr[1];
+        let __ret: [G; OUT_498] = [__v_28, __v_29];
+        record.function_queries[498].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_596: usize = 2;
-const IN_596: usize = 2;
-const OUT_596: usize = 1;
-fn aiur_fn_596(
-  inp: [G; IN_596],
+const INPUT_SIZE_499: usize = 25;
+const IN_499: usize = 25;
+const OUT_499: usize = 2;
+fn aiur_fn_499(
+  inp: [G; IN_499],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_596], ExecError> {
+) -> Result<[G; OUT_499], 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() {
-      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_6: G = __loaded[0];
-        let __v_7: G = __loaded[1];
-        let __v_8: G = __loaded[2];
-        let __v_9: G = __loaded[3];
-        match __v_6.as_canonical_u64() {
-          0u64 => {
-            let __v_10: G = { let __a_val = __v_3.as_canonical_u64(); let __b_val = __v_7.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_11: G = { let __a_val = __v_7.as_canonical_u64(); let __b_val = __v_3.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_12: G = (__v_10 + __v_11);
-            match __v_12.as_canonical_u64() {
-              0u64 => {
-                let __v_13: G = G::from_u64(1);
-                let __ret: [G; OUT_596] = [__v_13];
-                record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              _ => {
-                let __v_13: G = G::from_u64(0);
-                let __ret: [G; OUT_596] = [__v_13];
-                record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-            }
-          },
-          _ => {
-            let __v_10: G = G::from_u64(0);
-            let __ret: [G; OUT_596] = [__v_10];
-            record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-        }
-      },
+    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_0.as_canonical_u64() {
       1u64 => {
-        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_6: G = __loaded[0];
-        let __v_7: G = __loaded[1];
-        let __v_8: G = __loaded[2];
-        let __v_9: G = __loaded[3];
-        match __v_6.as_canonical_u64() {
+        match __v_12.as_canonical_u64() {
           1u64 => {
-            let __v_10: G = G::from_u64(1);
-            let __ret: [G; OUT_596] = [__v_10];
-            record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_1, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[475].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_475] = unsafe { *(result.output.as_ptr() as *const [G; OUT_475]) }; __ret } else { aiur_fn_475(__args, record, io_buffer, __cu)? } };
+            let __v_25: G = __r_arr[0];
+            let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } };
+            let __v_26: G = __r_arr[0];
+            let __v_27: G = __r_arr[1];
+            let __r_arr: [G; OUT_493] = { let __args: [G; IN_493] = [__v_2, __v_14, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[493].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_493] = unsafe { *(result.output.as_ptr() as *const [G; OUT_493]) }; __ret } else { aiur_fn_493(__args, record, io_buffer, __cu)? } };
+            let __v_28: G = __r_arr[0];
+            let __v_29: G = __r_arr[1];
+            let __r_arr: [G; OUT_493] = { let __args: [G; IN_493] = [__v_3, __v_15, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[493].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_493] = unsafe { *(result.output.as_ptr() as *const [G; OUT_493]) }; __ret } else { aiur_fn_493(__args, record, io_buffer, __cu)? } };
+            let __v_30: G = __r_arr[0];
+            let __v_31: G = __r_arr[1];
+            let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_28, __v_29, __v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[480].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_480] = unsafe { *(result.output.as_ptr() as *const [G; OUT_480]) }; __ret } else { aiur_fn_480(__args, record, io_buffer, __cu)? } };
+            let __v_32: G = __r_arr[0];
+            let __v_33: G = __r_arr[1];
+            let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_26, __v_27, __v_32, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[480].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_480] = unsafe { *(result.output.as_ptr() as *const [G; OUT_480]) }; __ret } else { aiur_fn_480(__args, record, io_buffer, __cu)? } };
+            let __v_34: G = __r_arr[0];
+            let __v_35: G = __r_arr[1];
+            let __ret: [G; OUT_499] = [__v_34, __v_35];
+            record.function_queries[499].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __v_10: G = G::from_u64(0);
-            let __ret: [G; OUT_596] = [__v_10];
-            record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __r_arr: [G; OUT_478] = { let __args: [G; IN_478] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[478].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_478] = unsafe { *(result.output.as_ptr() as *const [G; OUT_478]) }; __ret } else { aiur_fn_478(__args, record, io_buffer, __cu)? } };
+            let __v_25: G = __r_arr[0];
+            let __v_26: G = __r_arr[1];
+            let __ret: [G; OUT_499] = [__v_25, __v_26];
+            record.function_queries[499].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
-      2u64 => {
-        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_6: G = __loaded[0];
-        let __v_7: G = __loaded[1];
-        let __v_8: G = __loaded[2];
-        let __v_9: G = __loaded[3];
-        match __v_6.as_canonical_u64() {
-          2u64 => {
-            let __v_10: G = { let __a_val = __v_3.as_canonical_u64(); let __b_val = __v_7.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_11: G = { let __a_val = __v_7.as_canonical_u64(); let __b_val = __v_3.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_12: G = (__v_10 + __v_11);
-            match __v_12.as_canonical_u64() {
-              0u64 => {
-                let __v_13: G = G::from_u64(1);
-                let __ret: [G; OUT_596] = [__v_13];
-                record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              _ => {
-                let __v_13: G = G::from_u64(0);
-                let __ret: [G; OUT_596] = [__v_13];
-                record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-            }
+      5u64 => {
+        match __v_12.as_canonical_u64() {
+          5u64 => {
+            let __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_6, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[475].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_475] = unsafe { *(result.output.as_ptr() as *const [G; OUT_475]) }; __ret } else { aiur_fn_475(__args, record, io_buffer, __cu)? } };
+            let __v_25: G = __r_arr[0];
+            let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } };
+            let __v_26: G = __r_arr[0];
+            let __v_27: G = __r_arr[1];
+            let __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_1, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[475].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_475] = unsafe { *(result.output.as_ptr() as *const [G; OUT_475]) }; __ret } else { aiur_fn_475(__args, record, io_buffer, __cu)? } };
+            let __v_28: G = __r_arr[0];
+            let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } };
+            let __v_29: G = __r_arr[0];
+            let __v_30: G = __r_arr[1];
+            let __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[475].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_475] = unsafe { *(result.output.as_ptr() as *const [G; OUT_475]) }; __ret } else { aiur_fn_475(__args, record, io_buffer, __cu)? } };
+            let __v_31: G = __r_arr[0];
+            let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } };
+            let __v_32: G = __r_arr[0];
+            let __v_33: G = __r_arr[1];
+            let __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_4, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[475].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_475] = unsafe { *(result.output.as_ptr() as *const [G; OUT_475]) }; __ret } else { aiur_fn_475(__args, record, io_buffer, __cu)? } };
+            let __v_34: G = __r_arr[0];
+            let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } };
+            let __v_35: G = __r_arr[0];
+            let __v_36: G = __r_arr[1];
+            let __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_5, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[475].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_475] = unsafe { *(result.output.as_ptr() as *const [G; OUT_475]) }; __ret } else { aiur_fn_475(__args, record, io_buffer, __cu)? } };
+            let __v_37: G = __r_arr[0];
+            let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } };
+            let __v_38: G = __r_arr[0];
+            let __v_39: G = __r_arr[1];
+            let __r_arr: [G; OUT_493] = { let __args: [G; IN_493] = [__v_2, __v_14, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[493].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_493] = unsafe { *(result.output.as_ptr() as *const [G; OUT_493]) }; __ret } else { aiur_fn_493(__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 __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_7, __v_8, __v_19, __v_20, __v_5, __v_24, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[500].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_500] = unsafe { *(result.output.as_ptr() as *const [G; OUT_500]) }; __ret } else { aiur_fn_500(__args, record, io_buffer, __cu)? } };
+            let __v_43: G = __r_arr[0];
+            let __v_44: G = __r_arr[1];
+            let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_40, __v_41, __v_43, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[480].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_480] = unsafe { *(result.output.as_ptr() as *const [G; OUT_480]) }; __ret } else { aiur_fn_480(__args, record, io_buffer, __cu)? } };
+            let __v_45: G = __r_arr[0];
+            let __v_46: G = __r_arr[1];
+            let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_38, __v_39, __v_45, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[480].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_480] = unsafe { *(result.output.as_ptr() as *const [G; OUT_480]) }; __ret } else { aiur_fn_480(__args, record, io_buffer, __cu)? } };
+            let __v_47: G = __r_arr[0];
+            let __v_48: G = __r_arr[1];
+            let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_35, __v_36, __v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[480].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_480] = unsafe { *(result.output.as_ptr() as *const [G; OUT_480]) }; __ret } else { aiur_fn_480(__args, record, io_buffer, __cu)? } };
+            let __v_49: G = __r_arr[0];
+            let __v_50: G = __r_arr[1];
+            let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_32, __v_33, __v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[480].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_480] = unsafe { *(result.output.as_ptr() as *const [G; OUT_480]) }; __ret } else { aiur_fn_480(__args, record, io_buffer, __cu)? } };
+            let __v_51: G = __r_arr[0];
+            let __v_52: G = __r_arr[1];
+            let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_29, __v_30, __v_51, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[480].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_480] = unsafe { *(result.output.as_ptr() as *const [G; OUT_480]) }; __ret } else { aiur_fn_480(__args, record, io_buffer, __cu)? } };
+            let __v_53: G = __r_arr[0];
+            let __v_54: G = __r_arr[1];
+            let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_26, __v_27, __v_53, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[480].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_480] = unsafe { *(result.output.as_ptr() as *const [G; OUT_480]) }; __ret } else { aiur_fn_480(__args, record, io_buffer, __cu)? } };
+            let __v_55: G = __r_arr[0];
+            let __v_56: G = __r_arr[1];
+            let __ret: [G; OUT_499] = [__v_55, __v_56];
+            record.function_queries[499].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
           },
           _ => {
-            let __v_10: G = G::from_u64(0);
-            let __ret: [G; OUT_596] = [__v_10];
-            record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __r_arr: [G; OUT_478] = { let __args: [G; IN_478] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[478].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_478] = unsafe { *(result.output.as_ptr() as *const [G; OUT_478]) }; __ret } else { aiur_fn_478(__args, record, io_buffer, __cu)? } };
+            let __v_25: G = __r_arr[0];
+            let __v_26: G = __r_arr[1];
+            let __ret: [G; OUT_499] = [__v_25, __v_26];
+            record.function_queries[499].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
-      3u64 => {
-        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_6: G = __loaded[0];
-        let __v_7: G = __loaded[1];
-        let __v_8: G = __loaded[2];
-        let __v_9: G = __loaded[3];
-        match __v_6.as_canonical_u64() {
-          3u64 => {
-            let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_3, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } else { aiur_fn_596(__args, record, io_buffer, __cu)? } };
-            let __v_10: G = __r_arr[0];
-            match __v_10.as_canonical_u64() {
-              1u64 => {
-                let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } else { aiur_fn_596(__args, record, io_buffer, __cu)? } };
-                let __v_11: G = __r_arr[0];
-                let __ret: [G; OUT_596] = [__v_11];
-                record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              _ => {
-                let __v_11: G = G::from_u64(0);
-                let __ret: [G; OUT_596] = [__v_11];
-                record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-            }
+      7u64 => {
+        match __v_12.as_canonical_u64() {
+          7u64 => {
+            let __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_1, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[475].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_475] = unsafe { *(result.output.as_ptr() as *const [G; OUT_475]) }; __ret } else { aiur_fn_475(__args, record, io_buffer, __cu)? } };
+            let __v_25: G = __r_arr[0];
+            let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } };
+            let __v_26: G = __r_arr[0];
+            let __v_27: G = __r_arr[1];
+            let __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[475].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_475] = unsafe { *(result.output.as_ptr() as *const [G; OUT_475]) }; __ret } else { aiur_fn_475(__args, record, io_buffer, __cu)? } };
+            let __v_28: G = __r_arr[0];
+            let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } };
+            let __v_29: G = __r_arr[0];
+            let __v_30: G = __r_arr[1];
+            let __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_4, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[475].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_475] = unsafe { *(result.output.as_ptr() as *const [G; OUT_475]) }; __ret } else { aiur_fn_475(__args, record, io_buffer, __cu)? } };
+            let __v_31: G = __r_arr[0];
+            let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } };
+            let __v_32: G = __r_arr[0];
+            let __v_33: G = __r_arr[1];
+            let __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_5, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[475].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_475] = unsafe { *(result.output.as_ptr() as *const [G; OUT_475]) }; __ret } else { aiur_fn_475(__args, record, io_buffer, __cu)? } };
+            let __v_34: G = __r_arr[0];
+            let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } };
+            let __v_35: G = __r_arr[0];
+            let __v_36: G = __r_arr[1];
+            let __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_6, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[475].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_475] = unsafe { *(result.output.as_ptr() as *const [G; OUT_475]) }; __ret } else { aiur_fn_475(__args, record, io_buffer, __cu)? } };
+            let __v_37: G = __r_arr[0];
+            let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } };
+            let __v_38: G = __r_arr[0];
+            let __v_39: G = __r_arr[1];
+            let __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_8, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[475].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_475] = unsafe { *(result.output.as_ptr() as *const [G; OUT_475]) }; __ret } else { aiur_fn_475(__args, record, io_buffer, __cu)? } };
+            let __v_40: G = __r_arr[0];
+            let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } };
+            let __v_41: G = __r_arr[0];
+            let __v_42: G = __r_arr[1];
+            let __r_arr: [G; OUT_493] = { let __args: [G; IN_493] = [__v_2, __v_14, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[493].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_493] = unsafe { *(result.output.as_ptr() as *const [G; OUT_493]) }; __ret } else { aiur_fn_493(__args, record, io_buffer, __cu)? } };
+            let __v_43: G = __r_arr[0];
+            let __v_44: G = __r_arr[1];
+            let __r_arr: [G; OUT_496] = { let __args: [G; IN_496] = [__v_7, __v_19, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[496].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_496] = unsafe { *(result.output.as_ptr() as *const [G; OUT_496]) }; __ret } else { aiur_fn_496(__args, record, io_buffer, __cu)? } };
+            let __v_45: G = __r_arr[0];
+            let __v_46: G = __r_arr[1];
+            let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_43, __v_44, __v_45, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[480].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_480] = unsafe { *(result.output.as_ptr() as *const [G; OUT_480]) }; __ret } else { aiur_fn_480(__args, record, io_buffer, __cu)? } };
+            let __v_47: G = __r_arr[0];
+            let __v_48: G = __r_arr[1];
+            let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_41, __v_42, __v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[480].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_480] = unsafe { *(result.output.as_ptr() as *const [G; OUT_480]) }; __ret } else { aiur_fn_480(__args, record, io_buffer, __cu)? } };
+            let __v_49: G = __r_arr[0];
+            let __v_50: G = __r_arr[1];
+            let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_38, __v_39, __v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[480].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_480] = unsafe { *(result.output.as_ptr() as *const [G; OUT_480]) }; __ret } else { aiur_fn_480(__args, record, io_buffer, __cu)? } };
+            let __v_51: G = __r_arr[0];
+            let __v_52: G = __r_arr[1];
+            let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_35, __v_36, __v_51, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[480].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_480] = unsafe { *(result.output.as_ptr() as *const [G; OUT_480]) }; __ret } else { aiur_fn_480(__args, record, io_buffer, __cu)? } };
+            let __v_53: G = __r_arr[0];
+            let __v_54: G = __r_arr[1];
+            let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_32, __v_33, __v_53, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[480].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_480] = unsafe { *(result.output.as_ptr() as *const [G; OUT_480]) }; __ret } else { aiur_fn_480(__args, record, io_buffer, __cu)? } };
+            let __v_55: G = __r_arr[0];
+            let __v_56: G = __r_arr[1];
+            let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_29, __v_30, __v_55, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[480].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_480] = unsafe { *(result.output.as_ptr() as *const [G; OUT_480]) }; __ret } else { aiur_fn_480(__args, record, io_buffer, __cu)? } };
+            let __v_57: G = __r_arr[0];
+            let __v_58: G = __r_arr[1];
+            let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_26, __v_27, __v_57, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[480].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_480] = unsafe { *(result.output.as_ptr() as *const [G; OUT_480]) }; __ret } else { aiur_fn_480(__args, record, io_buffer, __cu)? } };
+            let __v_59: G = __r_arr[0];
+            let __v_60: G = __r_arr[1];
+            let __ret: [G; OUT_499] = [__v_59, __v_60];
+            record.function_queries[499].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
           },
           _ => {
-            let __v_10: G = G::from_u64(0);
-            let __ret: [G; OUT_596] = [__v_10];
-            record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __r_arr: [G; OUT_478] = { let __args: [G; IN_478] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[478].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_478] = unsafe { *(result.output.as_ptr() as *const [G; OUT_478]) }; __ret } else { aiur_fn_478(__args, record, io_buffer, __cu)? } };
+            let __v_25: G = __r_arr[0];
+            let __v_26: G = __r_arr[1];
+            let __ret: [G; OUT_499] = [__v_25, __v_26];
+            record.function_queries[499].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
-      4u64 => {
-        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_6: G = __loaded[0];
-        let __v_7: G = __loaded[1];
-        let __v_8: G = __loaded[2];
-        let __v_9: G = __loaded[3];
-        match __v_6.as_canonical_u64() {
-          4u64 => {
-            let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_3, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } else { aiur_fn_596(__args, record, io_buffer, __cu)? } };
-            let __v_10: G = __r_arr[0];
-            match __v_10.as_canonical_u64() {
-              1u64 => {
-                let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } else { aiur_fn_596(__args, record, io_buffer, __cu)? } };
-                let __v_11: G = __r_arr[0];
-                let __ret: [G; OUT_596] = [__v_11];
-                record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              _ => {
-                let __v_11: G = G::from_u64(0);
-                let __ret: [G; OUT_596] = [__v_11];
-                record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-            }
-          },
-          _ => {
-            let __v_10: G = G::from_u64(0);
-            let __ret: [G; OUT_596] = [__v_10];
-            record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+      _ => {
+        let __r_arr: [G; OUT_478] = { let __args: [G; IN_478] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[478].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_478] = unsafe { *(result.output.as_ptr() as *const [G; OUT_478]) }; __ret } else { aiur_fn_478(__args, record, io_buffer, __cu)? } };
+        let __v_25: G = __r_arr[0];
+        let __v_26: G = __r_arr[1];
+        let __ret: [G; OUT_499] = [__v_25, __v_26];
+        record.function_queries[499].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_500: usize = 7;
+const IN_500: usize = 7;
+const OUT_500: usize = 2;
+fn aiur_fn_500(
+  inp: [G; IN_500],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_500], 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 = (__v_4 - __v_6);
+    match __v_7.as_canonical_u64() {
+      0u64 => {
+        let __r_arr: [G; OUT_478] = { let __args: [G; IN_478] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[478].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_478] = unsafe { *(result.output.as_ptr() as *const [G; OUT_478]) }; __ret } else { aiur_fn_478(__args, record, io_buffer, __cu)? } };
+        let __v_8: G = __r_arr[0];
+        let __v_9: G = __r_arr[1];
+        let __ret: [G; OUT_500] = [__v_8, __v_9];
+        record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_0, __v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[261].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_261] = unsafe { *(result.output.as_ptr() as *const [G; OUT_261]) }; __ret } else { aiur_fn_261(__args, record, io_buffer, __cu)? } };
+        let __v_8: G = __r_arr[0];
+        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].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 __v_17: G = __loaded[8];
+        let __v_18: G = __loaded[9];
+        let __v_19: G = __loaded[10];
+        let __v_20: G = __loaded[11];
+        let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_2, __v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[261].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_261] = unsafe { *(result.output.as_ptr() as *const [G; OUT_261]) }; __ret } else { aiur_fn_261(__args, record, io_buffer, __cu)? } };
+        let __v_21: G = __r_arr[0];
+        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; 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: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+        let __v_22: G = __loaded[0];
+        let __v_23: G = __loaded[1];
+        let __v_24: G = __loaded[2];
+        let __v_25: G = __loaded[3];
+        let __v_26: G = __loaded[4];
+        let __v_27: G = __loaded[5];
+        let __v_28: G = __loaded[6];
+        let __v_29: G = __loaded[7];
+        let __v_30: G = __loaded[8];
+        let __v_31: G = __loaded[9];
+        let __v_32: G = __loaded[10];
+        let __v_33: G = __loaded[11];
+        let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = [__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_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[501].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_501] = unsafe { *(result.output.as_ptr() as *const [G; OUT_501]) }; __ret } else { aiur_fn_501(__args, record, io_buffer, __cu)? } };
+        let __v_34: G = __r_arr[0];
+        let __v_35: G = __r_arr[1];
+        let __v_36: G = G::from_u64(1);
+        let __v_37: G = (__v_6 + __v_36);
+        let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[500].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_500] = unsafe { *(result.output.as_ptr() as *const [G; OUT_500]) }; __ret } else { aiur_fn_500(__args, record, io_buffer, __cu)? } };
+        let __v_38: G = __r_arr[0];
+        let __v_39: G = __r_arr[1];
+        let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_34, __v_35, __v_38, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[480].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_480] = unsafe { *(result.output.as_ptr() as *const [G; OUT_480]) }; __ret } else { aiur_fn_480(__args, record, io_buffer, __cu)? } };
+        let __v_40: G = __r_arr[0];
+        let __v_41: G = __r_arr[1];
+        let __ret: [G; OUT_500] = [__v_40, __v_41];
+        record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_501: usize = 25;
+const IN_501: usize = 25;
+const OUT_501: usize = 2;
+fn aiur_fn_501(
+  inp: [G; IN_501],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_501], 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_0.as_canonical_u64() {
+      6u64 => {
+        match __v_12.as_canonical_u64() {
+          6u64 => {
+            let __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_1, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[475].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_475] = unsafe { *(result.output.as_ptr() as *const [G; OUT_475]) }; __ret } else { aiur_fn_475(__args, record, io_buffer, __cu)? } };
+            let __v_25: G = __r_arr[0];
+            let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } };
+            let __v_26: G = __r_arr[0];
+            let __v_27: G = __r_arr[1];
+            let __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_5, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[475].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_475] = unsafe { *(result.output.as_ptr() as *const [G; OUT_475]) }; __ret } else { aiur_fn_475(__args, record, io_buffer, __cu)? } };
+            let __v_28: G = __r_arr[0];
+            let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } };
+            let __v_29: G = __r_arr[0];
+            let __v_30: G = __r_arr[1];
+            let __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_6, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[475].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_475] = unsafe { *(result.output.as_ptr() as *const [G; OUT_475]) }; __ret } else { aiur_fn_475(__args, record, io_buffer, __cu)? } };
+            let __v_31: G = __r_arr[0];
+            let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } };
+            let __v_32: G = __r_arr[0];
+            let __v_33: G = __r_arr[1];
+            let __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_7, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[475].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_475] = unsafe { *(result.output.as_ptr() as *const [G; OUT_475]) }; __ret } else { aiur_fn_475(__args, record, io_buffer, __cu)? } };
+            let __v_34: G = __r_arr[0];
+            let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } };
+            let __v_35: G = __r_arr[0];
+            let __v_36: G = __r_arr[1];
+            let __r_arr: [G; OUT_493] = { let __args: [G; IN_493] = [__v_2, __v_14, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[493].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_493] = unsafe { *(result.output.as_ptr() as *const [G; OUT_493]) }; __ret } else { aiur_fn_493(__args, record, io_buffer, __cu)? } };
+            let __v_37: G = __r_arr[0];
+            let __v_38: G = __r_arr[1];
+            let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_35, __v_36, __v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[480].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_480] = unsafe { *(result.output.as_ptr() as *const [G; OUT_480]) }; __ret } else { aiur_fn_480(__args, record, io_buffer, __cu)? } };
+            let __v_39: G = __r_arr[0];
+            let __v_40: G = __r_arr[1];
+            let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_32, __v_33, __v_39, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[480].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_480] = unsafe { *(result.output.as_ptr() as *const [G; OUT_480]) }; __ret } else { aiur_fn_480(__args, record, io_buffer, __cu)? } };
+            let __v_41: G = __r_arr[0];
+            let __v_42: G = __r_arr[1];
+            let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_29, __v_30, __v_41, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[480].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_480] = unsafe { *(result.output.as_ptr() as *const [G; OUT_480]) }; __ret } else { aiur_fn_480(__args, record, io_buffer, __cu)? } };
+            let __v_43: G = __r_arr[0];
+            let __v_44: G = __r_arr[1];
+            let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_26, __v_27, __v_43, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[480].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_480] = unsafe { *(result.output.as_ptr() as *const [G; OUT_480]) }; __ret } else { aiur_fn_480(__args, record, io_buffer, __cu)? } };
+            let __v_45: G = __r_arr[0];
+            let __v_46: G = __r_arr[1];
+            let __ret: [G; OUT_501] = [__v_45, __v_46];
+            record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
-        }
-      },
-      5u64 => {
-        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_6: G = __loaded[0];
-        let __v_7: G = __loaded[1];
-        let __v_8: G = __loaded[2];
-        let __v_9: G = __loaded[3];
-        match __v_6.as_canonical_u64() {
-          5u64 => {
-            let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_3, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } else { aiur_fn_596(__args, record, io_buffer, __cu)? } };
-            let __v_10: G = __r_arr[0];
-            match __v_10.as_canonical_u64() {
-              1u64 => {
-                let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } else { aiur_fn_596(__args, record, io_buffer, __cu)? } };
-                let __v_11: G = __r_arr[0];
-                let __ret: [G; OUT_596] = [__v_11];
-                record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              _ => {
-                let __v_11: G = G::from_u64(0);
-                let __ret: [G; OUT_596] = [__v_11];
-                record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-            }
-          },
           _ => {
-            let __v_10: G = G::from_u64(0);
-            let __ret: [G; OUT_596] = [__v_10];
-            record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __r_arr: [G; OUT_497] = { let __args: [G; IN_497] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[497].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_497] = unsafe { *(result.output.as_ptr() as *const [G; OUT_497]) }; __ret } else { aiur_fn_497(__args, record, io_buffer, __cu)? } };
+            let __v_25: G = __r_arr[0];
+            let __r_arr: [G; OUT_497] = { let __args: [G; IN_497] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[497].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_497] = unsafe { *(result.output.as_ptr() as *const [G; OUT_497]) }; __ret } else { aiur_fn_497(__args, record, io_buffer, __cu)? } };
+            let __v_26: G = __r_arr[0];
+            let __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[475].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_475] = unsafe { *(result.output.as_ptr() as *const [G; OUT_475]) }; __ret } else { aiur_fn_475(__args, record, io_buffer, __cu)? } };
+            let __v_27: G = __r_arr[0];
+            let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } };
+            let __v_28: G = __r_arr[0];
+            let __v_29: G = __r_arr[1];
+            let __ret: [G; OUT_501] = [__v_28, __v_29];
+            record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
       _ => {
-        let __v_6: G = G::from_u64(0);
-        let __ret: [G; OUT_596] = [__v_6];
-        record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_497] = { let __args: [G; IN_497] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[497].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_497] = unsafe { *(result.output.as_ptr() as *const [G; OUT_497]) }; __ret } else { aiur_fn_497(__args, record, io_buffer, __cu)? } };
+        let __v_25: G = __r_arr[0];
+        let __r_arr: [G; OUT_497] = { let __args: [G; IN_497] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[497].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_497] = unsafe { *(result.output.as_ptr() as *const [G; OUT_497]) }; __ret } else { aiur_fn_497(__args, record, io_buffer, __cu)? } };
+        let __v_26: G = __r_arr[0];
+        let __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[475].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_475] = unsafe { *(result.output.as_ptr() as *const [G; OUT_475]) }; __ret } else { aiur_fn_475(__args, record, io_buffer, __cu)? } };
+        let __v_27: G = __r_arr[0];
+        let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } };
+        let __v_28: G = __r_arr[0];
+        let __v_29: G = __r_arr[1];
+        let __ret: [G; OUT_501] = [__v_28, __v_29];
+        record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_597: usize = 8;
-const IN_597: usize = 8;
-const OUT_597: usize = 1;
-fn aiur_fn_597(
-  inp: [G; IN_597],
+const INPUT_SIZE_502: usize = 3;
+const IN_502: usize = 3;
+const OUT_502: usize = 1;
+fn aiur_fn_502(
+  inp: [G; IN_502],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_597], ExecError> {
+) -> Result<[G; OUT_502], 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 __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_7, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-    let __v_8: G = __r_arr[0];
-    let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].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 __v_17: G = __loaded[8];
-    let __v_18: G = __loaded[9];
-    let __v_19: G = __loaded[10];
-    match __v_9.as_canonical_u64() {
+    let __v_3: G = G::from_u64(4);
+    let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[265].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_265] = unsafe { *(result.output.as_ptr() as *const [G; OUT_265]) }; __ret } else { aiur_fn_265(__args, record, io_buffer, __cu)? } };
+    let __v_4: G = __r_arr[0];
+    let __v_5: G = __r_arr[1];
+    let __v_6: G = __r_arr[2];
+    let __v_7: G = __r_arr[3];
+    let __v_8: G = __r_arr[4];
+    let __v_9: G = __r_arr[5];
+    let __v_10: G = __r_arr[6];
+    let __v_11: G = __r_arr[7];
+    let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[265].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_265] = unsafe { *(result.output.as_ptr() as *const [G; OUT_265]) }; __ret } else { aiur_fn_265(__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 = G::from_u64(0);
+    let __v_21: G = G::from_u64(1);
+    let __v_22: G = G::from_u64(1);
+    let __v_23: G = { let __values: [G; 3] = [__v_21, __v_22, __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 = G::from_u64(1);
+    let __v_25: G = G::from_u64(1);
+    let __v_26: G = { let __values: [G; 3] = [__v_24, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_27: G = G::from_u64(1);
+    let __v_28: G = G::from_u64(1);
+    let __v_29: G = { let __values: [G; 3] = [__v_27, __v_28, __v_28]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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 = G::from_u64(1);
+    let __v_31: G = G::from_u64(1);
+    let __v_32: G = { let __values: [G; 3] = [__v_30, __v_31, __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 __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__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_0, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_23, __v_26, __v_29, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[67].get_mut(&__args[..]) { 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_33: G = __r_arr[0];
+    let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[18].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_18] = unsafe { *(result.output.as_ptr() as *const [G; OUT_18]) }; __ret } else { aiur_fn_18(__args, record, io_buffer, __cu)? } };
+    let __v_34: G = __r_arr[0];
+    let __ret: [G; OUT_502] = [__v_34];
+    record.function_queries[502].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_503: usize = 2;
+const IN_503: usize = 2;
+const OUT_503: usize = 12;
+fn aiur_fn_503(
+  inp: [G; IN_503],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_503], 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_713] = { let __args: [G; IN_713] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } };
+    let __v_2: G = __r_arr[0];
+    let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[258].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_258] = unsafe { *(result.output.as_ptr() as *const [G; OUT_258]) }; __ret } else { aiur_fn_258(__args, record, io_buffer, __cu)? } };
+    let __v_3: G = __r_arr[0];
+    let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; 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: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+    let __v_4: G = __loaded[0];
+    let __v_5: G = __loaded[1];
+    let __v_6: G = __loaded[2];
+    let __v_7: G = __loaded[3];
+    let __v_8: G = __loaded[4];
+    let __v_9: G = __loaded[5];
+    let __v_10: G = __loaded[6];
+    let __v_11: G = __loaded[7];
+    let __v_12: G = __loaded[8];
+    let __v_13: G = __loaded[9];
+    let __v_14: G = __loaded[10];
+    let __v_15: G = __loaded[11];
+    let __ret: [G; OUT_503] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15];
+    record.function_queries[503].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_504: usize = 2;
+const IN_504: usize = 2;
+const OUT_504: usize = 1;
+fn aiur_fn_504(
+  inp: [G; IN_504],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_504], 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_503] = { let __args: [G; IN_503] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[503].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_503] = unsafe { *(result.output.as_ptr() as *const [G; OUT_503]) }; __ret } else { aiur_fn_503(__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 = __r_arr[10];
+    let __v_13: G = __r_arr[11];
+    match __v_2.as_canonical_u64() {
       5u64 => {
-        let __r_arr: [G; OUT_588] = { let __args: [G; IN_588] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[588].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_588] = unsafe { *(result.output.as_ptr() as *const [G; OUT_588]) }; __ret } else { aiur_fn_588(__args, record, io_buffer, __cu)? } };
-        let __v_20: G = __r_arr[0];
-        let __v_21: G = G::from_u64(0);
-        let __v_22: G = G::from_u64(0);
-        let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_6, __v_5, __v_20, __v_21, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = unsafe { *(result.output.as_ptr() as *const [G; OUT_598]) }; __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } };
-        let __v_23: G = __r_arr[0];
-        let __ret: [G; OUT_597] = [__v_23];
-        record.function_queries[597].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_504] = [__v_7];
+        record.function_queries[504].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __v_20: G = G::from_u64(0);
-        let __ret: [G; OUT_597] = [__v_20];
-        record.function_queries[597].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __v_14: G = G::from_u64(0);
+        let __ret: [G; OUT_504] = [__v_14];
+        record.function_queries[504].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_598: usize = 5;
-const IN_598: usize = 5;
-const OUT_598: usize = 1;
-fn aiur_fn_598(
-  inp: [G; IN_598],
+const INPUT_SIZE_505: usize = 3;
+const IN_505: usize = 3;
+const OUT_505: usize = 1;
+fn aiur_fn_505(
+  inp: [G; IN_505],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_598], ExecError> {
+) -> Result<[G; OUT_505], 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 = G::from_u64(0);
+    let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } else { aiur_fn_711(__args, record, io_buffer, __cu)? } };
+    let __v_4: G = __r_arr[0];
+    let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = [__v_0, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[506].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_506] = unsafe { *(result.output.as_ptr() as *const [G; OUT_506]) }; __ret } else { aiur_fn_506(__args, record, io_buffer, __cu)? } };
+    let __v_5: G = __r_arr[0];
+    let __ret: [G; OUT_505] = [__v_5];
+    record.function_queries[505].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_506: usize = 5;
+const IN_506: usize = 5;
+const OUT_506: usize = 1;
+fn aiur_fn_506(
+  inp: [G; IN_506],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_506], 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 __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; 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: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
+    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_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];
     match __v_5.as_canonical_u64() {
       1u64 => {
-        match __v_4.as_canonical_u64() {
-          0u64 => {
-            let __v_11: G = G::from_u64(0);
-            let __ret: [G; OUT_598] = [__v_11];
-            record.function_queries[598].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            let __v_11: G = G::from_u64(1);
-            let __v_12: G = (__v_4 - __v_11);
-            let __ret: [G; OUT_598] = [__v_12];
-            record.function_queries[598].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-        }
+        let __v_8: G = G::from_u64(1);
+        let __v_9: G = G::from_u64(1);
+        let __v_10: G = { let __values: [G; 4] = [__v_8, __v_9, __v_9, __v_9]; 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_506] = [__v_10];
+        record.function_queries[506].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
       0u64 => {
-        let __v_11: G = { let __a_val = __v_6.as_canonical_u64(); let __b_val = __v_1.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_12: G = { let __a_val = __v_1.as_canonical_u64(); let __b_val = __v_6.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_13: G = (__v_11 + __v_12);
-        match __v_13.as_canonical_u64() {
-          0u64 => {
-            let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_4.as_canonical_u64() {
-  0u64 => {
-    let __v_14: G = G::from_u64(1);
-    let __v_15: G = (__v_3 + __v_14);
-    break '__mc_0 [__v_15];
-  },
-  _ => {
-    break '__mc_0 [__v_4];
-  },
+        let __r_arr: [G; OUT_507] = { let __args: [G; IN_507] = [__v_6, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[507].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_507] = unsafe { *(result.output.as_ptr() as *const [G; OUT_507]) }; __ret } else { aiur_fn_507(__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_3 + __v_10);
+        let __v_12: G = (__v_4 + __v_9);
+        let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = [__v_7, __v_1, __v_2, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[506].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_506] = unsafe { *(result.output.as_ptr() as *const [G; OUT_506]) }; __ret } else { aiur_fn_506(__args, record, io_buffer, __cu)? } };
+        let __v_13: G = __r_arr[0];
+        let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[706].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_706] = unsafe { *(result.output.as_ptr() as *const [G; OUT_706]) }; __ret } else { aiur_fn_706(__args, record, io_buffer, __cu)? } };
+        let __v_14: G = __r_arr[0];
+        let __ret: [G; OUT_506] = [__v_14];
+        record.function_queries[506].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
+      },
+    }
+  })
 }
- };
-            let __v_14: G = __mc_out___mc_0[0];
-            match __v_7.as_canonical_u64() {
-              0u64 => {
-                let __ret: [G; OUT_598] = [__v_3];
-                record.function_queries[598].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              _ => {
-                let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = unsafe { *(result.output.as_ptr() as *const [G; OUT_606]) }; __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } };
-                let __v_15: G = __r_arr[0];
-                match __v_15.as_canonical_u64() {
-                  1u64 => {
-                    let __ret: [G; OUT_598] = [__v_3];
-                    record.function_queries[598].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
-                  0u64 => {
-                    let __v_16: G = G::from_u64(1);
-                    let __v_17: G = (__v_3 + __v_16);
-                    let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_10, __v_1, __v_2, __v_17, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = unsafe { *(result.output.as_ptr() as *const [G; OUT_598]) }; __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } };
-                    let __v_18: G = __r_arr[0];
-                    let __ret: [G; OUT_598] = [__v_18];
-                    record.function_queries[598].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
-                  _ => {
-                    return Err(ExecError::MatchNoCase(__v_15.as_canonical_u64()));
-                  },
-                }
-              },
-            }
+
+const INPUT_SIZE_507: usize = 5;
+const IN_507: usize = 5;
+const OUT_507: usize = 2;
+fn aiur_fn_507(
+  inp: [G; IN_507],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_507], 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 __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_5: G = __loaded[0];
+    let __v_6: G = __loaded[1];
+    let __v_7: G = __loaded[2];
+    match __v_5.as_canonical_u64() {
+      1u64 => {
+        let __v_8: G = G::from_u64(1);
+        let __v_9: G = G::from_u64(1);
+        let __v_10: G = { let __values: [G; 4] = [__v_8, __v_9, __v_9, __v_9]; 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_11: G = G::from_u64(0);
+        let __ret: [G; OUT_507] = [__v_10, __v_11];
+        record.function_queries[507].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __r_arr: [G; OUT_507] = { let __args: [G; IN_507] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[507].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_507] = unsafe { *(result.output.as_ptr() as *const [G; OUT_507]) }; __ret } else { aiur_fn_507(__args, record, io_buffer, __cu)? } };
+        let __v_8: G = __r_arr[0];
+        let __v_9: G = __r_arr[1];
+        let __r_arr: [G; OUT_504] = { let __args: [G; IN_504] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[504].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_504] = unsafe { *(result.output.as_ptr() as *const [G; OUT_504]) }; __ret } else { aiur_fn_504(__args, record, io_buffer, __cu)? } };
+        let __v_10: G = __r_arr[0];
+        let __v_11: G = G::from_u64(0);
+        let __r_arr: [G; OUT_508] = { let __args: [G; IN_508] = [__v_2, __v_6, __v_10, __v_4, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[508].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_508] = unsafe { *(result.output.as_ptr() as *const [G; OUT_508]) }; __ret } else { aiur_fn_508(__args, record, io_buffer, __cu)? } };
+        let __v_12: G = __r_arr[0];
+        let __v_13: G = G::from_u64(0);
+        let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } };
+        let __v_14: G = __r_arr[0];
+        let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_12, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[706].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_706] = unsafe { *(result.output.as_ptr() as *const [G; OUT_706]) }; __ret } else { aiur_fn_706(__args, record, io_buffer, __cu)? } };
+        let __v_15: G = __r_arr[0];
+        let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_3, __v_15]; 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_17: G = { let __a_val = __v_9.as_canonical_u64(); let __b_val = __v_10.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_17.as_canonical_u64() {
+          1u64 => {
+            let __ret: [G; OUT_507] = [__v_16, __v_10];
+            record.function_queries[507].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
           },
           _ => {
-            let __v_14: G = G::from_u64(1);
-            let __v_15: G = (__v_3 + __v_14);
-            let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_10, __v_1, __v_2, __v_15, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = unsafe { *(result.output.as_ptr() as *const [G; OUT_598]) }; __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } };
-            let __v_16: G = __r_arr[0];
-            let __ret: [G; OUT_598] = [__v_16];
-            record.function_queries[598].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_507] = [__v_16, __v_9];
+            record.function_queries[507].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -51282,458 +43083,554 @@ fn aiur_fn_598(
   })
 }
 
-const INPUT_SIZE_599: usize = 14;
-const IN_599: usize = 14;
-const OUT_599: usize = 0;
-fn aiur_fn_599(
-  inp: [G; IN_599],
+const INPUT_SIZE_508: usize = 5;
+const IN_508: usize = 5;
+const OUT_508: usize = 1;
+fn aiur_fn_508(
+  inp: [G; IN_508],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_599], ExecError> {
+) -> Result<[G; OUT_508], 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];
-    match __v_1.as_canonical_u64() {
-      7u64 => {
-        let __r_arr: [G; OUT_587] = { let __args: [G; IN_587] = [__v_8, __v_3, __v_4, __v_6, __v_7, __v_5, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[587].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_587] = unsafe { *(result.output.as_ptr() as *const [G; OUT_587]) }; __ret } else { aiur_fn_587(__args, record, io_buffer, __cu)? } };
-        let __v_14: G = __r_arr[0];
-        let __r_arr: [G; OUT_514] = { let __args: [G; IN_514] = [__v_14, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[514].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_514] = unsafe { *(result.output.as_ptr() as *const [G; OUT_514]) }; __ret } else { aiur_fn_514(__args, record, io_buffer, __cu)? } };
-        let __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_14, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[634].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_634] = unsafe { *(result.output.as_ptr() as *const [G; OUT_634]) }; __ret } else { aiur_fn_634(__args, record, io_buffer, __cu)? } };
-        let __v_15: G = __r_arr[0];
-        let __r_arr: [G; OUT_595] = { let __args: [G; IN_595] = [__v_14, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[595].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_595] = unsafe { *(result.output.as_ptr() as *const [G; OUT_595]) }; __ret } else { aiur_fn_595(__args, record, io_buffer, __cu)? } };
-        let __v_16: G = __r_arr[0];
-        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_12, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-        let __v_17: G = __r_arr[0];
-        let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_17.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].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];
-        let __v_22: G = __loaded[4];
-        let __v_23: G = __loaded[5];
-        let __v_24: G = __loaded[6];
-        let __v_25: G = __loaded[7];
-        let __v_26: G = __loaded[8];
-        let __v_27: G = __loaded[9];
-        let __v_28: G = __loaded[10];
-        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_12, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-        let __v_29: G = __r_arr[0];
-        let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_29.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr };
-        let __v_30: G = __loaded[0];
-        let __v_31: G = __loaded[1];
-        let __v_32: G = __loaded[2];
-        let __v_33: G = __loaded[3];
-        let __v_34: G = __loaded[4];
-        let __v_35: G = __loaded[5];
-        let __v_36: G = __loaded[6];
-        let __v_37: G = __loaded[7];
-        let __v_38: G = __loaded[8];
-        let __v_39: G = __loaded[9];
-        let __v_40: G = __loaded[10];
-        if (__v_9 != __v_16) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_16.as_canonical_u64() });
-        }
-        match __v_18.as_canonical_u64() {
-          5u64 => {
-            match __v_30.as_canonical_u64() {
-              5u64 => {
-                let __v_41: G = (__v_33 + __v_34);
-                let __v_42: G = G::from_u64(1);
-                let __v_43: G = G::from_u64(1);
-                let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __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 __r_arr: [G; OUT_519] = { let __args: [G; IN_519] = [__v_32, __v_41, __v_44, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[519].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_519] = unsafe { *(result.output.as_ptr() as *const [G; OUT_519]) }; __ret } else { aiur_fn_519(__args, record, io_buffer, __cu)? } };
-                let __v_45: G = __r_arr[0];
-                let __r_arr: [G; OUT_537] = { let __args: [G; IN_537] = [__v_45, __v_35, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[537].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_537] = unsafe { *(result.output.as_ptr() as *const [G; OUT_537]) }; __ret } else { aiur_fn_537(__args, record, io_buffer, __cu)? } };
-                let __v_46: G = __r_arr[0];
-                let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_46.as_canonical_u64() {
-  1u64 => {
-    let __v_47: G = G::from_u64(4);
-    let __v_48: G = G::from_u64(0);
-    let __v_49: G = G::from_u64(0);
-    let __v_50: G = { let __values: [G; 3] = [__v_47, __v_48, __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 } };
-    break '__mc_0 [__v_50];
-  },
-  0u64 => {
-    let __v_47: G = G::from_u64(0);
-    let __v_48: G = G::from_u64(0);
-    let __v_49: G = { let __values: [G; 3] = [__v_47, __v_48, __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 } };
-    break '__mc_0 [__v_49];
-  },
-  _ => {
-    return Err(ExecError::MatchNoCase(__v_46.as_canonical_u64()));
-  },
+    let __v_5: G = (__v_2 - __v_4);
+    match __v_5.as_canonical_u64() {
+      0u64 => {
+        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_508] = [__v_8];
+        record.function_queries[508].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __v_6: G = G::from_u64(0);
+        let __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = [__v_0, __v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[502].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_502] = unsafe { *(result.output.as_ptr() as *const [G; OUT_502]) }; __ret } else { aiur_fn_502(__args, record, io_buffer, __cu)? } };
+        let __v_7: G = __r_arr[0];
+        let __v_8: G = (__v_3 + __v_4);
+        let __v_9: G = G::from_u64(1);
+        let __v_10: G = (__v_4 + __v_9);
+        let __r_arr: [G; OUT_508] = { let __args: [G; IN_508] = [__v_0, __v_1, __v_2, __v_3, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[508].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_508] = unsafe { *(result.output.as_ptr() as *const [G; OUT_508]) }; __ret } else { aiur_fn_508(__args, record, io_buffer, __cu)? } };
+        let __v_11: G = __r_arr[0];
+        let __v_12: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_11]; 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_508] = [__v_12];
+        record.function_queries[508].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+    }
+  })
 }
- };
-                let __v_47: G = __mc_out___mc_0[0];
-                let __r_arr: [G; OUT_559] = { let __args: [G; IN_559] = [__v_15, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[559].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_559] = unsafe { *(result.output.as_ptr() as *const [G; OUT_559]) }; __ret } else { aiur_fn_559(__args, record, io_buffer, __cu)? } };
-                let __v_48: G = __r_arr[0];
-                let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_48, __v_46, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } };
-                let __v_49: G = __r_arr[0];
-                let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = [__v_3, __v_4, __v_6, __v_7, __v_5, __v_14, __v_49, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[597].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_597] = unsafe { *(result.output.as_ptr() as *const [G; OUT_597]) }; __ret } else { aiur_fn_597(__args, record, io_buffer, __cu)? } };
-                let __v_50: G = __r_arr[0];
-                let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_14, __v_32, __v_35, __v_21, __v_34, __v_19, __v_33, __v_15, __v_50, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[582].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_582] = unsafe { *(result.output.as_ptr() as *const [G; OUT_582]) }; __ret } else { aiur_fn_582(__args, record, io_buffer, __cu)? } };
-                let __v_51: G = __r_arr[0];
-                let __v_52: G = G::from_u64(1);
-                let __v_53: G = G::from_u64(1);
-                let __v_54: G = { let __values: [G; 3] = [__v_52, __v_53, __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 __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_3, __v_51, __v_54, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } };
-                let __v_55: G = __r_arr[0];
-                let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = unsafe { *(result.output.as_ptr() as *const [G; OUT_608]) }; __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } };
-                let __v_56: G = __r_arr[0];
-                let __r_arr: [G; OUT_794] = { let __args: [G; IN_794] = [__v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[794].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_794] = unsafe { *(result.output.as_ptr() as *const [G; OUT_794]) }; __ret } else { aiur_fn_794(__args, record, io_buffer, __cu)? } };
-                let __v_57: G = __r_arr[0];
-                let __r_arr: [G; OUT_633] = { let __args: [G; IN_633] = [__v_49, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[633].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_633] = unsafe { *(result.output.as_ptr() as *const [G; OUT_633]) }; __ret } else { aiur_fn_633(__args, record, io_buffer, __cu)? } };
-                let __v_58: G = __r_arr[0];
-                let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_49, __v_21, __v_19, __v_47, __v_46, __v_21, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } else { aiur_fn_577(__args, record, io_buffer, __cu)? } };
-                let __v_59: G = __r_arr[0];
-                let __v_60: G = G::from_u64(0);
-                let __r_arr: [G; OUT_579] = { let __args: [G; IN_579] = [__v_49, __v_56, __v_58, __v_21, __v_57, __v_19, __v_46, __v_21, __v_12, __v_13, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[579].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_579] = unsafe { *(result.output.as_ptr() as *const [G; OUT_579]) }; __ret } else { aiur_fn_579(__args, record, io_buffer, __cu)? } };
-                let __v_61: G = __r_arr[0];
-                let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { 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_62: G = __r_arr[0];
-                let __v_63: G = G::from_u64(0);
-                let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_56, __v_50, __v_12, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[639].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_639] = unsafe { *(result.output.as_ptr() as *const [G; OUT_639]) }; __ret } else { aiur_fn_639(__args, record, io_buffer, __cu)? } };
-                let __v_64: G = __r_arr[0];
-                let __v_65: G = G::from_u64(0);
-                let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_46, __v_19, __v_65]; let __cu = unconstrained; if let Some(result) = record.function_queries[552].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_552] = unsafe { *(result.output.as_ptr() as *const [G; OUT_552]) }; __ret } else { aiur_fn_552(__args, record, io_buffer, __cu)? } };
-                let __v_66: G = __r_arr[0];
-                let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_20, __v_66]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } };
-                let __v_67: G = __r_arr[0];
-                let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_67, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[573].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_573] = unsafe { *(result.output.as_ptr() as *const [G; OUT_573]) }; __ret } else { aiur_fn_573(__args, record, io_buffer, __cu)? } };
-                let __v_68: G = __r_arr[0];
-                let __v_69: G = __r_arr[1];
-                let __v_70: G = G::from_u64(1);
-                if (__v_55 != __v_70) {
-                  return Err(ExecError::AssertEqMismatch { lhs: __v_55.as_canonical_u64(), rhs: __v_70.as_canonical_u64() });
-                }
-                let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_49, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[591].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_591] = unsafe { *(result.output.as_ptr() as *const [G; OUT_591]) }; __ret } else { aiur_fn_591(__args, record, io_buffer, __cu)? } };
-                let __v_71: G = __r_arr[0];
-                let __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[609].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_609] = unsafe { *(result.output.as_ptr() as *const [G; OUT_609]) }; __ret } else { aiur_fn_609(__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 __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_0, __v_14, __v_35, __v_21, __v_57, __v_62, __v_19, __v_46, __v_59, __v_61, __v_68, __v_71, __v_49, __v_56, __v_58, __v_73, __v_74, __v_75, __v_12, __v_13, __v_64]; let __cu = unconstrained; if let Some(result) = record.function_queries[648].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_648] = unsafe { *(result.output.as_ptr() as *const [G; OUT_648]) }; __ret } else { aiur_fn_648(__args, record, io_buffer, __cu)? } };
-                let __v_76: G = __r_arr[0];
-                let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_8, __v_76, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } };
-                let __ret: [G; OUT_599] = [];
-                record.function_queries[599].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              _ => {
-                return Err(ExecError::MatchNoCase(__v_30.as_canonical_u64()));
-              },
-            }
+
+const INPUT_SIZE_509: usize = 3;
+const IN_509: usize = 3;
+const OUT_509: usize = 1;
+fn aiur_fn_509(
+  inp: [G; IN_509],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_509], 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 = G::from_u64(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 __v_7: G = { let __values: [G; 3] = [__v_3, __v_0, __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 __v_8: G = G::from_u64(1);
+    let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } else { aiur_fn_711(__args, record, io_buffer, __cu)? } };
+    let __v_9: G = __r_arr[0];
+    let __v_10: G = (__v_8 + __v_9);
+    let __r_arr: [G; OUT_510] = { let __args: [G; IN_510] = [__v_7, __v_1, __v_2, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[510].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_510] = unsafe { *(result.output.as_ptr() as *const [G; OUT_510]) }; __ret } else { aiur_fn_510(__args, record, io_buffer, __cu)? } };
+    let __v_11: G = __r_arr[0];
+    let __ret: [G; OUT_509] = [__v_11];
+    record.function_queries[509].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_510: usize = 4;
+const IN_510: usize = 4;
+const OUT_510: usize = 1;
+fn aiur_fn_510(
+  inp: [G; IN_510],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_510], 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 __ret: [G; OUT_510] = [__v_0];
+        record.function_queries[510].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_505] = { let __args: [G; IN_505] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[505].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_505] = unsafe { *(result.output.as_ptr() as *const [G; OUT_505]) }; __ret } else { aiur_fn_505(__args, record, io_buffer, __cu)? } };
+        let __v_4: G = __r_arr[0];
+        let __r_arr: [G; OUT_511] = { let __args: [G; IN_511] = [__v_0, __v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[511].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_511] = unsafe { *(result.output.as_ptr() as *const [G; OUT_511]) }; __ret } else { aiur_fn_511(__args, record, io_buffer, __cu)? } };
+        let __v_5: G = __r_arr[0];
+        let __r_arr: [G; OUT_517] = { let __args: [G; IN_517] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[517].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_517] = unsafe { *(result.output.as_ptr() as *const [G; OUT_517]) }; __ret } else { aiur_fn_517(__args, record, io_buffer, __cu)? } };
+        let __v_6: G = __r_arr[0];
+        match __v_6.as_canonical_u64() {
+          1u64 => {
+            let __ret: [G; OUT_510] = [__v_0];
+            record.function_queries[510].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
           },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_18.as_canonical_u64()));
+            let __v_7: G = G::from_u64(1);
+            let __v_8: G = (__v_3 - __v_7);
+            let __r_arr: [G; OUT_510] = { let __args: [G; IN_510] = [__v_5, __v_1, __v_2, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[510].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_510] = unsafe { *(result.output.as_ptr() as *const [G; OUT_510]) }; __ret } else { aiur_fn_510(__args, record, io_buffer, __cu)? } };
+            let __v_9: G = __r_arr[0];
+            let __ret: [G; OUT_510] = [__v_9];
+            record.function_queries[510].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
           },
         }
       },
+    }
+  })
+}
+
+const INPUT_SIZE_511: usize = 3;
+const IN_511: usize = 3;
+const OUT_511: usize = 1;
+fn aiur_fn_511(
+  inp: [G; IN_511],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_511], 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_511] = [__v_8];
+        record.function_queries[511].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __r_arr: [G; OUT_512] = { let __args: [G; IN_512] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[512].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_512] = unsafe { *(result.output.as_ptr() as *const [G; OUT_512]) }; __ret } else { aiur_fn_512(__args, record, io_buffer, __cu)? } };
+        let __v_6: G = __r_arr[0];
+        let __r_arr: [G; OUT_511] = { let __args: [G; IN_511] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[511].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_511] = unsafe { *(result.output.as_ptr() as *const [G; OUT_511]) }; __ret } else { aiur_fn_511(__args, record, io_buffer, __cu)? } };
+        let __v_7: G = __r_arr[0];
+        let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[710].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_710] = unsafe { *(result.output.as_ptr() as *const [G; OUT_710]) }; __ret } else { aiur_fn_710(__args, record, io_buffer, __cu)? } };
+        let __v_8: G = __r_arr[0];
+        let __ret: [G; OUT_511] = [__v_8];
+        record.function_queries[511].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_600: usize = 4;
-const IN_600: usize = 4;
-const OUT_600: usize = 1;
-fn aiur_fn_600(
-  inp: [G; IN_600],
+const INPUT_SIZE_512: usize = 3;
+const IN_512: usize = 3;
+const OUT_512: usize = 1;
+fn aiur_fn_512(
+  inp: [G; IN_512],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_512], 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_711] = { let __args: [G; IN_711] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } else { aiur_fn_711(__args, record, io_buffer, __cu)? } };
+    let __v_3: G = __r_arr[0];
+    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; 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_512] = [__v_6];
+        record.function_queries[512].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 __v_8: G = { let __values: [G; 3] = [__v_4, __v_0, __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_512] = [__v_8];
+        record.function_queries[512].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_513] = { let __args: [G; IN_513] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[513].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_513] = unsafe { *(result.output.as_ptr() as *const [G; OUT_513]) }; __ret } else { aiur_fn_513(__args, record, io_buffer, __cu)? } };
+        let __v_4: G = __r_arr[0];
+        let __r_arr: [G; OUT_515] = { let __args: [G; IN_515] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[515].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_515] = unsafe { *(result.output.as_ptr() as *const [G; OUT_515]) }; __ret } else { aiur_fn_515(__args, record, io_buffer, __cu)? } };
+        let __v_5: G = __r_arr[0];
+        let __ret: [G; OUT_512] = [__v_5];
+        record.function_queries[512].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_513: usize = 3;
+const IN_513: usize = 3;
+const OUT_513: usize = 1;
+fn aiur_fn_513(
+  inp: [G; IN_513],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_600], ExecError> {
+) -> Result<[G; OUT_513], 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_607] = { let __args: [G; IN_607] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[607].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_607] = unsafe { *(result.output.as_ptr() as *const [G; OUT_607]) }; __ret } else { aiur_fn_607(__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_601] = { let __args: [G; IN_601] = [__v_4, __v_5, __v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[601].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_601] = unsafe { *(result.output.as_ptr() as *const [G; OUT_601]) }; __ret } else { aiur_fn_601(__args, record, io_buffer, __cu)? } };
-    let __v_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { 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_7: G = __r_arr[0];
-    let __r_arr: [G; OUT_794] = { let __args: [G; IN_794] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[794].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_794] = unsafe { *(result.output.as_ptr() as *const [G; OUT_794]) }; __ret } else { aiur_fn_794(__args, record, io_buffer, __cu)? } };
-    let __v_8: G = __r_arr[0];
-    let __v_9: G = (__v_8 - __v_7);
-    let __v_10: G = G::from_u64(1);
-    let __v_11: G = { let __a_val = __v_10.as_canonical_u64(); let __b_val = __v_9.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_11.as_canonical_u64() {
-      0u64 => {
-        let __ret: [G; OUT_600] = [__v_6];
-        record.function_queries[600].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_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_513] = [__v_8];
+        record.function_queries[513].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      1u64 => {
-        let __r_arr: [G; OUT_610] = { let __args: [G; IN_610] = [__v_6, __v_7, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[610].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_610] = unsafe { *(result.output.as_ptr() as *const [G; OUT_610]) }; __ret } else { aiur_fn_610(__args, record, io_buffer, __cu)? } };
-        let __v_12: G = __r_arr[0];
-        let __ret: [G; OUT_600] = [__v_12];
-        record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+      0u64 => {
+        let __r_arr: [G; OUT_513] = { let __args: [G; IN_513] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[513].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_513] = unsafe { *(result.output.as_ptr() as *const [G; OUT_513]) }; __ret } else { aiur_fn_513(__args, record, io_buffer, __cu)? } };
+        let __v_6: G = __r_arr[0];
+        let __r_arr: [G; OUT_514] = { let __args: [G; IN_514] = [__v_4, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[514].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_514] = unsafe { *(result.output.as_ptr() as *const [G; OUT_514]) }; __ret } else { aiur_fn_514(__args, record, io_buffer, __cu)? } };
+        let __v_7: G = __r_arr[0];
+        let __ret: [G; OUT_513] = [__v_7];
+        record.function_queries[513].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64()));
+        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_601: usize = 5;
-const IN_601: usize = 5;
-const OUT_601: usize = 1;
-fn aiur_fn_601(
-  inp: [G; IN_601],
+const INPUT_SIZE_514: usize = 4;
+const IN_514: usize = 4;
+const OUT_514: usize = 1;
+fn aiur_fn_514(
+  inp: [G; IN_514],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_601], ExecError> {
+) -> Result<[G; OUT_514], 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_794] = { let __args: [G; IN_794] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[794].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_794] = unsafe { *(result.output.as_ptr() as *const [G; OUT_794]) }; __ret } else { aiur_fn_794(__args, record, io_buffer, __cu)? } };
-    let __v_5: G = __r_arr[0];
-    let __v_6: G = { let __a_val = __v_1.as_canonical_u64(); let __b_val = __v_5.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_6.as_canonical_u64() {
-      0u64 => {
-        let __ret: [G; OUT_601] = [__v_0];
-        record.function_queries[601].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_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(0);
+        let __v_8: G = G::from_u64(1);
+        let __v_9: G = G::from_u64(1);
+        let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __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_7, __v_0, __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 __ret: [G; OUT_514] = [__v_11];
+        record.function_queries[514].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      _ => {
-        let __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[609].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_609] = unsafe { *(result.output.as_ptr() as *const [G; OUT_609]) }; __ret } else { aiur_fn_609(__args, record, io_buffer, __cu)? } };
+      0u64 => {
+        let __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = [__v_3, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[503].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_503] = unsafe { *(result.output.as_ptr() as *const [G; OUT_503]) }; __ret } else { aiur_fn_503(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
         let __v_8: G = __r_arr[1];
         let __v_9: G = __r_arr[2];
         let __v_10: G = __r_arr[3];
-        let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_7, __v_8, __v_9, __v_10, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[602].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_602] = unsafe { *(result.output.as_ptr() as *const [G; OUT_602]) }; __ret } else { aiur_fn_602(__args, record, io_buffer, __cu)? } };
-        let __v_11: G = __r_arr[0];
-        let __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[604].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_604] = unsafe { *(result.output.as_ptr() as *const [G; OUT_604]) }; __ret } else { aiur_fn_604(__args, record, io_buffer, __cu)? } };
-        let __v_12: G = __r_arr[0];
-        let __v_13: G = G::from_u64(1);
-        let __v_14: G = (__v_1 + __v_13);
-        let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = [__v_12, __v_14, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[601].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_601] = unsafe { *(result.output.as_ptr() as *const [G; OUT_601]) }; __ret } else { aiur_fn_601(__args, record, io_buffer, __cu)? } };
-        let __v_15: G = __r_arr[0];
-        let __ret: [G; OUT_601] = [__v_15];
-        record.function_queries[601].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
+        let __v_11: G = __r_arr[4];
+        let __v_12: G = __r_arr[5];
+        let __v_13: G = __r_arr[6];
+        let __v_14: G = __r_arr[7];
+        let __v_15: G = __r_arr[8];
+        let __v_16: G = __r_arr[9];
+        let __v_17: G = __r_arr[10];
+        let __v_18: G = __r_arr[11];
+        let __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[503].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_503] = unsafe { *(result.output.as_ptr() as *const [G; OUT_503]) }; __ret } else { aiur_fn_503(__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 __v_28: G = __r_arr[9];
+        let __v_29: G = __r_arr[10];
+        let __v_30: G = __r_arr[11];
+        let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__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_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[498].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_498] = unsafe { *(result.output.as_ptr() as *const [G; OUT_498]) }; __ret } else { aiur_fn_498(__args, record, io_buffer, __cu)? } };
+        let __v_31: G = __r_arr[0];
+        let __v_32: G = __r_arr[1];
+        match __v_31.as_canonical_u64() {
+          0u64 => {
+            let __v_33: G = G::from_u64(0);
+            let __v_34: G = { let __values: [G; 3] = [__v_33, __v_0, __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_514] = [__v_34];
+            record.function_queries[514].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            let __v_33: G = G::from_u64(0);
+            let __r_arr: [G; OUT_514] = { let __args: [G; IN_514] = [__v_0, __v_6, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[514].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_514] = unsafe { *(result.output.as_ptr() as *const [G; OUT_514]) }; __ret } else { aiur_fn_514(__args, record, io_buffer, __cu)? } };
+            let __v_34: G = __r_arr[0];
+            let __v_35: G = { let __values: [G; 3] = [__v_33, __v_5, __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 __ret: [G; OUT_514] = [__v_35];
+            record.function_queries[514].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_602: usize = 7;
-const IN_602: usize = 7;
-const OUT_602: usize = 1;
-fn aiur_fn_602(
-  inp: [G; IN_602],
+const INPUT_SIZE_515: usize = 3;
+const IN_515: usize = 3;
+const OUT_515: usize = 1;
+fn aiur_fn_515(
+  inp: [G; IN_515],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_602], ExecError> {
+) -> Result<[G; OUT_515], 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 __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_5, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-    let __v_7: G = __r_arr[0];
-    let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].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];
-    let __v_18: G = __loaded[10];
-    match __v_8.as_canonical_u64() {
-      5u64 => {
-        let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_13, __v_11, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[603].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_603] = unsafe { *(result.output.as_ptr() as *const [G; OUT_603]) }; __ret } else { aiur_fn_603(__args, record, io_buffer, __cu)? } };
-        let __v_19: G = __r_arr[0];
-        let __ret: [G; OUT_602] = [__v_19];
-        record.function_queries[602].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_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_515] = [__v_8];
+        record.function_queries[515].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      _ => {
-        let __v_19: G = G::from_u64(1);
-        let __v_20: G = G::from_u64(1);
-        let __v_21: G = { let __values: [G; 5] = [__v_19, __v_20, __v_20, __v_20, __v_20]; 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_602] = [__v_21];
-        record.function_queries[602].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+      0u64 => {
+        let __v_6: G = G::from_u64(0);
+        let __v_7: G = G::from_u64(1);
+        let __v_8: G = G::from_u64(1);
+        let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __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_10: G = { let __values: [G; 3] = [__v_6, __v_4, __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 __r_arr: [G; OUT_516] = { let __args: [G; IN_516] = [__v_5, __v_1, __v_2, __v_4, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[516].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_516] = unsafe { *(result.output.as_ptr() as *const [G; OUT_516]) }; __ret } else { aiur_fn_516(__args, record, io_buffer, __cu)? } };
+        let __v_11: G = __r_arr[0];
+        let __ret: [G; OUT_515] = [__v_11];
+        record.function_queries[515].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
+      },
     }
   })
 }
 
-const INPUT_SIZE_603: usize = 8;
-const IN_603: usize = 8;
-const OUT_603: usize = 1;
-fn aiur_fn_603(
-  inp: [G; IN_603],
+const INPUT_SIZE_516: usize = 5;
+const IN_516: usize = 5;
+const OUT_516: usize = 1;
+fn aiur_fn_516(
+  inp: [G; IN_516],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_603], ExecError> {
+) -> Result<[G; OUT_516], 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; 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_8: G = __loaded[0];
-    let __v_9: G = __loaded[1];
-    let __v_10: G = __loaded[2];
-    match __v_8.as_canonical_u64() {
+    let __v_5: G = __loaded[0];
+    let __v_6: G = __loaded[1];
+    let __v_7: G = __loaded[2];
+    match __v_5.as_canonical_u64() {
       1u64 => {
-        let __v_11: G = G::from_u64(1);
-        let __v_12: G = G::from_u64(1);
-        let __v_13: G = { let __values: [G; 5] = [__v_11, __v_12, __v_12, __v_12, __v_12]; 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_603] = [__v_13];
-        record.function_queries[603].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __v_8: G = G::from_u64(0);
+        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 __v_12: G = { let __values: [G; 3] = [__v_8, __v_4, __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_516] = [__v_12];
+        record.function_queries[516].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-        let __v_11: G = __r_arr[0];
-        let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr };
-        let __v_12: G = __loaded[0];
-        let __v_13: G = __loaded[1];
-        let __v_14: G = __loaded[2];
-        let __v_15: G = __loaded[3];
-        let __v_16: G = __loaded[4];
-        let __v_17: G = __loaded[5];
-        let __v_18: G = __loaded[6];
-        let __v_19: G = __loaded[7];
-        let __v_20: G = __loaded[8];
-        let __v_21: G = __loaded[9];
-        let __v_22: G = __loaded[10];
-        match __v_12.as_canonical_u64() {
-          6u64 => {
-            let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_2.as_canonical_u64() {
-  0u64 => {
-    let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_14, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } };
-    let __v_23: G = __r_arr[0];
-    let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_23, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } else { aiur_fn_524(__args, record, io_buffer, __cu)? } };
-    let __v_24: G = __r_arr[0];
-    break '__mc_0 [__v_24];
-  },
-  _ => {
-    let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_14, __v_1, __v_3, __v_4, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[647].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_647] = unsafe { *(result.output.as_ptr() as *const [G; OUT_647]) }; __ret } else { aiur_fn_647(__args, record, io_buffer, __cu)? } };
-    let __v_23: G = __r_arr[0];
-    break '__mc_0 [__v_23];
-  },
-}
- };
-            let __v_23: G = __mc_out___mc_0[0];
-            let __v_24: G = G::from_u64(0);
-            let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_23, __v_5, __v_6, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[642].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_642] = unsafe { *(result.output.as_ptr() as *const [G; OUT_642]) }; __ret } else { aiur_fn_642(__args, record, io_buffer, __cu)? } };
-            let __v_25: G = __r_arr[0];
-            let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_10, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[603].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_603] = unsafe { *(result.output.as_ptr() as *const [G; OUT_603]) }; __ret } else { aiur_fn_603(__args, record, io_buffer, __cu)? } };
-            let __v_26: G = __r_arr[0];
-            let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } else { aiur_fn_775(__args, record, io_buffer, __cu)? } };
-            let __v_27: G = __r_arr[0];
-            let __ret: [G; OUT_603] = [__v_27];
-            record.function_queries[603].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[503].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_503] = unsafe { *(result.output.as_ptr() as *const [G; OUT_503]) }; __ret } else { aiur_fn_503(__args, record, io_buffer, __cu)? } };
+        let __v_8: G = __r_arr[0];
+        let __v_9: G = __r_arr[1];
+        let __v_10: G = __r_arr[2];
+        let __v_11: G = __r_arr[3];
+        let __v_12: G = __r_arr[4];
+        let __v_13: G = __r_arr[5];
+        let __v_14: G = __r_arr[6];
+        let __v_15: G = __r_arr[7];
+        let __v_16: G = __r_arr[8];
+        let __v_17: G = __r_arr[9];
+        let __v_18: G = __r_arr[10];
+        let __v_19: G = __r_arr[11];
+        let __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = [__v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[503].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_503] = unsafe { *(result.output.as_ptr() as *const [G; OUT_503]) }; __ret } else { aiur_fn_503(__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 __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__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_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[498].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_498] = unsafe { *(result.output.as_ptr() as *const [G; OUT_498]) }; __ret } else { aiur_fn_498(__args, record, io_buffer, __cu)? } };
+        let __v_32: G = __r_arr[0];
+        let __v_33: G = __r_arr[1];
+        match __v_32.as_canonical_u64() {
+          1u64 => {
+            let __r_arr: [G; OUT_704] = { let __args: [G; IN_704] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[704].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_704] = unsafe { *(result.output.as_ptr() as *const [G; OUT_704]) }; __ret } else { aiur_fn_704(__args, record, io_buffer, __cu)? } };
+            let __v_34: G = __r_arr[0];
+            let __r_arr: [G; OUT_516] = { let __args: [G; IN_516] = [__v_7, __v_1, __v_2, __v_6, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[516].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_516] = unsafe { *(result.output.as_ptr() as *const [G; OUT_516]) }; __ret } else { aiur_fn_516(__args, record, io_buffer, __cu)? } };
+            let __v_35: G = __r_arr[0];
+            let __ret: [G; OUT_516] = [__v_35];
+            record.function_queries[516].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_10, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[603].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_603] = unsafe { *(result.output.as_ptr() as *const [G; OUT_603]) }; __ret } else { aiur_fn_603(__args, record, io_buffer, __cu)? } };
-            let __v_23: G = __r_arr[0];
-            let __ret: [G; OUT_603] = [__v_23];
-            record.function_queries[603].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __v_34: G = G::from_u64(0);
+            let __v_35: G = G::from_u64(0);
+            let __v_36: G = G::from_u64(1);
+            let __v_37: G = G::from_u64(1);
+            let __v_38: G = { let __values: [G; 3] = [__v_36, __v_37, __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_35, __v_6, __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 __r_arr: [G; OUT_516] = { let __args: [G; IN_516] = [__v_7, __v_1, __v_2, __v_6, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[516].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_516] = unsafe { *(result.output.as_ptr() as *const [G; OUT_516]) }; __ret } else { aiur_fn_516(__args, record, io_buffer, __cu)? } };
+            let __v_40: G = __r_arr[0];
+            let __v_41: G = { let __values: [G; 3] = [__v_34, __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 __ret: [G; OUT_516] = [__v_41];
+            record.function_queries[516].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64()));
+        return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_604: usize = 2;
-const IN_604: usize = 2;
-const OUT_604: usize = 1;
-fn aiur_fn_604(
-  inp: [G; IN_604],
+const INPUT_SIZE_517: usize = 2;
+const IN_517: usize = 2;
+const OUT_517: usize = 1;
+fn aiur_fn_517(
+  inp: [G; IN_517],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_604], ExecError> {
+) -> Result<[G; OUT_517], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; 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: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr };
+    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];
-    let __v_5: G = __loaded[3];
-    let __v_6: G = __loaded[4];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_604] = [__v_0];
-        record.function_queries[604].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[605].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_605] = unsafe { *(result.output.as_ptr() as *const [G; OUT_605]) }; __ret } else { aiur_fn_605(__args, record, io_buffer, __cu)? } };
-        let __v_7: G = __r_arr[0];
-        match __v_7.as_canonical_u64() {
+        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_5: G = __loaded[0];
+        let __v_6: G = __loaded[1];
+        let __v_7: G = __loaded[2];
+        match __v_5.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[604].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_604] = unsafe { *(result.output.as_ptr() as *const [G; OUT_604]) }; __ret } else { aiur_fn_604(__args, record, io_buffer, __cu)? } };
-            let __v_8: G = __r_arr[0];
-            let __ret: [G; OUT_604] = [__v_8];
-            record.function_queries[604].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __v_8: G = G::from_u64(1);
+            let __ret: [G; OUT_517] = [__v_8];
+            record.function_queries[517].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 = G::from_u64(1);
-            let __v_11: G = G::from_u64(1);
-            let __v_12: G = { let __values: [G; 6] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11]; 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 __v_13: G = { let __values: [G; 6] = [__v_8, __v_3, __v_9, __v_4, __v_5, __v_12]; 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 __r_arr: [G; OUT_783] = { let __args: [G; IN_783] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[783].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_783] = unsafe { *(result.output.as_ptr() as *const [G; OUT_783]) }; __ret } else { aiur_fn_783(__args, record, io_buffer, __cu)? } };
-            let __v_14: G = __r_arr[0];
-            let __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_14, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[604].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_604] = unsafe { *(result.output.as_ptr() as *const [G; OUT_604]) }; __ret } else { aiur_fn_604(__args, record, io_buffer, __cu)? } };
-            let __v_15: G = __r_arr[0];
-            let __ret: [G; OUT_604] = [__v_15];
-            record.function_queries[604].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_517] = [__v_8];
+            record.function_queries[517].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_5: G = __loaded[0];
+        let __v_6: G = __loaded[1];
+        let __v_7: G = __loaded[2];
+        match __v_5.as_canonical_u64() {
+          1u64 => {
+            let __v_8: G = G::from_u64(0);
+            let __ret: [G; OUT_517] = [__v_8];
+            record.function_queries[517].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
+          0u64 => {
+            let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } else { aiur_fn_310(__args, record, io_buffer, __cu)? } };
+            let __v_8: G = __r_arr[0];
+            match __v_8.as_canonical_u64() {
+              0u64 => {
+                let __v_9: G = G::from_u64(0);
+                let __ret: [G; OUT_517] = [__v_9];
+                record.function_queries[517].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                let __r_arr: [G; OUT_517] = { let __args: [G; IN_517] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[517].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_517] = unsafe { *(result.output.as_ptr() as *const [G; OUT_517]) }; __ret } else { aiur_fn_517(__args, record, io_buffer, __cu)? } };
+                let __v_9: G = __r_arr[0];
+                let __ret: [G; OUT_517] = [__v_9];
+                record.function_queries[517].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+            }
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
+          },
         }
       },
       _ => {
@@ -51743,285 +43640,493 @@ fn aiur_fn_604(
   })
 }
 
-const INPUT_SIZE_605: usize = 3;
-const IN_605: usize = 3;
-const OUT_605: usize = 1;
-fn aiur_fn_605(
-  inp: [G; IN_605],
+const INPUT_SIZE_518: usize = 1;
+const IN_518: usize = 1;
+const OUT_518: usize = 1;
+fn aiur_fn_518(
+  inp: [G; IN_518],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_605], ExecError> {
+) -> Result<[G; OUT_518], 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; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; 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: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
-    let __v_3: G = __loaded[0];
-    let __v_4: G = __loaded[1];
-    let __v_5: G = __loaded[2];
-    let __v_6: G = __loaded[3];
-    let __v_7: G = __loaded[4];
-    let __v_8: G = __loaded[5];
-    match __v_3.as_canonical_u64() {
+    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_9: G = G::from_u64(0);
-        let __ret: [G; OUT_605] = [__v_9];
-        record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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_518] = [__v_6];
+        record.function_queries[518].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __v_9: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_1.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_10: G = { let __a_val = __v_1.as_canonical_u64(); let __b_val = __v_4.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_11: G = (__v_9 + __v_10);
-        match __v_11.as_canonical_u64() {
-          0u64 => {
-            match __v_5.as_canonical_u64() {
-              0u64 => {
-                let __v_12: G = G::from_u64(1);
-                let __ret: [G; OUT_605] = [__v_12];
-                record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              _ => {
-                let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_6, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = unsafe { *(result.output.as_ptr() as *const [G; OUT_606]) }; __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } };
-                let __v_12: G = __r_arr[0];
-                match __v_12.as_canonical_u64() {
-                  1u64 => {
-                    let __v_13: G = G::from_u64(1);
-                    let __ret: [G; OUT_605] = [__v_13];
-                    record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
-                  0u64 => {
-                    let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[605].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_605] = unsafe { *(result.output.as_ptr() as *const [G; OUT_605]) }; __ret } else { aiur_fn_605(__args, record, io_buffer, __cu)? } };
-                    let __v_13: G = __r_arr[0];
-                    let __ret: [G; OUT_605] = [__v_13];
-                    record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
-                  _ => {
-                    return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64()));
-                  },
-                }
-              },
-            }
+        let __r_arr: [G; OUT_518] = { let __args: [G; IN_518] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[518].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_518] = unsafe { *(result.output.as_ptr() as *const [G; OUT_518]) }; __ret } else { aiur_fn_518(__args, record, io_buffer, __cu)? } };
+        let __v_4: G = __r_arr[0];
+        let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[710].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_710] = unsafe { *(result.output.as_ptr() as *const [G; OUT_710]) }; __ret } else { aiur_fn_710(__args, record, io_buffer, __cu)? } };
+        let __v_5: G = __r_arr[0];
+        let __ret: [G; OUT_518] = [__v_5];
+        record.function_queries[518].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_519: usize = 1;
+const IN_519: usize = 1;
+const OUT_519: usize = 1;
+fn aiur_fn_519(
+  inp: [G; IN_519],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_519], 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(1);
+        let __ret: [G; OUT_519] = [__v_4];
+        record.function_queries[519].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } else { aiur_fn_711(__args, record, io_buffer, __cu)? } };
+        let __v_4: G = __r_arr[0];
+        match __v_4.as_canonical_u64() {
+          1u64 => {
+            let __r_arr: [G; OUT_519] = { let __args: [G; IN_519] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[519].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_519] = unsafe { *(result.output.as_ptr() as *const [G; OUT_519]) }; __ret } else { aiur_fn_519(__args, record, io_buffer, __cu)? } };
+            let __v_5: G = __r_arr[0];
+            let __ret: [G; OUT_519] = [__v_5];
+            record.function_queries[519].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[605].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_605] = unsafe { *(result.output.as_ptr() as *const [G; OUT_605]) }; __ret } else { aiur_fn_605(__args, record, io_buffer, __cu)? } };
-            let __v_12: G = __r_arr[0];
-            let __ret: [G; OUT_605] = [__v_12];
-            record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __v_5: G = G::from_u64(0);
+            let __ret: [G; OUT_519] = [__v_5];
+            record.function_queries[519].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_606: usize = 2;
-const IN_606: usize = 2;
-const OUT_606: usize = 1;
-fn aiur_fn_606(
-  inp: [G; IN_606],
+const INPUT_SIZE_520: usize = 2;
+const IN_520: usize = 2;
+const OUT_520: usize = 1;
+fn aiur_fn_520(
+  inp: [G; IN_520],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_606], ExecError> {
+) -> Result<[G; OUT_520], 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 __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; 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: 47 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 47] = __args[..47].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];
+    let __v_12: G = __loaded[10];
+    let __v_13: G = __loaded[11];
+    let __v_14: G = __loaded[12];
+    let __v_15: G = __loaded[13];
+    let __v_16: G = __loaded[14];
+    let __v_17: G = __loaded[15];
+    let __v_18: G = __loaded[16];
+    let __v_19: G = __loaded[17];
+    let __v_20: G = __loaded[18];
+    let __v_21: G = __loaded[19];
+    let __v_22: G = __loaded[20];
+    let __v_23: G = __loaded[21];
+    let __v_24: G = __loaded[22];
+    let __v_25: G = __loaded[23];
+    let __v_26: G = __loaded[24];
+    let __v_27: G = __loaded[25];
+    let __v_28: G = __loaded[26];
+    let __v_29: G = __loaded[27];
+    let __v_30: G = __loaded[28];
+    let __v_31: G = __loaded[29];
+    let __v_32: G = __loaded[30];
+    let __v_33: G = __loaded[31];
+    let __v_34: G = __loaded[32];
+    let __v_35: G = __loaded[33];
+    let __v_36: G = __loaded[34];
+    let __v_37: G = __loaded[35];
+    let __v_38: G = __loaded[36];
+    let __v_39: G = __loaded[37];
+    let __v_40: G = __loaded[38];
+    let __v_41: G = __loaded[39];
+    let __v_42: G = __loaded[40];
+    let __v_43: G = __loaded[41];
+    let __v_44: G = __loaded[42];
+    let __v_45: G = __loaded[43];
+    let __v_46: G = __loaded[44];
+    let __v_47: G = __loaded[45];
+    let __v_48: G = __loaded[46];
     match __v_2.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_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_5: G = __loaded[0];
-        let __v_6: G = __loaded[1];
-        let __v_7: G = __loaded[2];
-        match __v_5.as_canonical_u64() {
+        let __v_49: G = G::from_u64(1);
+        let __v_50: G = G::from_u64(1);
+        let __v_51: G = { let __values: [G; 3] = [__v_49, __v_50, __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 __ret: [G; OUT_520] = [__v_51];
+        record.function_queries[520].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __v_49: G = G::from_u64(1);
+        let __v_50: G = (__v_1 + __v_49);
+        let __r_arr: [G; OUT_520] = { let __args: [G; IN_520] = [__v_48, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[520].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_520] = unsafe { *(result.output.as_ptr() as *const [G; OUT_520]) }; __ret } else { aiur_fn_520(__args, record, io_buffer, __cu)? } };
+        let __v_51: G = __r_arr[0];
+        match __v_3.as_canonical_u64() {
           1u64 => {
-            let __v_8: G = G::from_u64(1);
-            let __ret: [G; OUT_606] = [__v_8];
-            record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          0u64 => {
-            let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_606] = [__v_8];
-            record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __v_52: G = G::from_u64(0);
+            let __v_53: G = { let __values: [G; 3] = [__v_52, __v_1, __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 __ret: [G; OUT_520] = [__v_53];
+            record.function_queries[520].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
+            let __ret: [G; OUT_520] = [__v_51];
+            record.function_queries[520].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_5: G = __loaded[0];
-        let __v_6: G = __loaded[1];
-        let __v_7: G = __loaded[2];
-        match __v_5.as_canonical_u64() {
-          1u64 => {
-            let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_606] = [__v_8];
-            record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          0u64 => {
-            let __v_8: G = (__v_3 - __v_6);
-            match __v_8.as_canonical_u64() {
-              0u64 => {
-                let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = unsafe { *(result.output.as_ptr() as *const [G; OUT_606]) }; __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } };
-                let __v_9: G = __r_arr[0];
-                let __ret: [G; OUT_606] = [__v_9];
-                record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_521: usize = 1;
+const IN_521: usize = 1;
+const OUT_521: usize = 0;
+fn aiur_fn_521(
+  inp: [G; IN_521],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_521], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } else { aiur_fn_255(__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 __v_11: G = __r_arr[10];
+    let __v_12: G = __r_arr[11];
+    let __v_13: G = __r_arr[12];
+    let __v_14: G = __r_arr[13];
+    let __v_15: G = __r_arr[14];
+    let __v_16: G = __r_arr[15];
+    let __v_17: G = __r_arr[16];
+    let __v_18: G = __r_arr[17];
+    let __v_19: G = __r_arr[18];
+    let __v_20: G = __r_arr[19];
+    let __v_21: G = __r_arr[20];
+    let __v_22: G = __r_arr[21];
+    let __v_23: G = __r_arr[22];
+    let __v_24: G = __r_arr[23];
+    let __v_25: G = __r_arr[24];
+    let __v_26: G = __r_arr[25];
+    let __v_27: G = __r_arr[26];
+    let __v_28: G = __r_arr[27];
+    let __v_29: G = __r_arr[28];
+    let __v_30: G = __r_arr[29];
+    let __v_31: G = __r_arr[30];
+    let __v_32: G = __r_arr[31];
+    let __v_33: G = __r_arr[32];
+    let __v_34: G = __r_arr[33];
+    let __v_35: G = __r_arr[34];
+    let __v_36: G = __r_arr[35];
+    let __v_37: G = __r_arr[36];
+    let __v_38: G = __r_arr[37];
+    let __v_39: G = __r_arr[38];
+    let __v_40: G = __r_arr[39];
+    let __v_41: G = __r_arr[40];
+    let __v_42: G = __r_arr[41];
+    let __v_43: G = __r_arr[42];
+    let __v_44: G = __r_arr[43];
+    let __v_45: G = __r_arr[44];
+    let __v_46: G = __r_arr[45];
+    let __v_47: G = __r_arr[46];
+    let __v_48: G = __r_arr[47];
+    match __v_1.as_canonical_u64() {
+      _ => {
+        match __v_1.as_canonical_u64() {
+          8u64 => {
+            let __v_49: G = G::from_u64(0);
+            let __r_arr: [G; OUT_520] = { let __args: [G; IN_520] = [__v_2, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[520].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_520] = unsafe { *(result.output.as_ptr() as *const [G; OUT_520]) }; __ret } else { aiur_fn_520(__args, record, io_buffer, __cu)? } };
+            let __v_50: G = __r_arr[0];
+            let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } else { aiur_fn_711(__args, record, io_buffer, __cu)? } };
+            let __v_51: G = __r_arr[0];
+            let __v_52: G = G::from_u64(2);
+            let __v_53: G = { let __a_val = __v_51.as_canonical_u64(); let __b_val = __v_52.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_53.as_canonical_u64() {
+              1u64 => {
+                let __ret: [G; OUT_521] = [];
+                record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                let __v_9: G = G::from_u64(0);
-                let __ret: [G; OUT_606] = [__v_9];
-                record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_2, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = unsafe { *(result.output.as_ptr() as *const [G; OUT_267]) }; __ret } else { aiur_fn_267(__args, record, io_buffer, __cu)? } };
+                let __v_54: G = __r_arr[0];
+                let __r_arr: [G; OUT_509] = { let __args: [G; IN_509] = [__v_50, __v_54, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[509].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_509] = unsafe { *(result.output.as_ptr() as *const [G; OUT_509]) }; __ret } else { aiur_fn_509(__args, record, io_buffer, __cu)? } };
+                let __v_55: G = __r_arr[0];
+                let __r_arr: [G; OUT_519] = { let __args: [G; IN_519] = [__v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[519].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_519] = unsafe { *(result.output.as_ptr() as *const [G; OUT_519]) }; __ret } else { aiur_fn_519(__args, record, io_buffer, __cu)? } };
+                let __v_56: G = __r_arr[0];
+                let __v_57: G = G::from_u64(1);
+                if (__v_56 != __v_57) {
+                  return Err(ExecError::AssertEqMismatch { lhs: __v_56.as_canonical_u64(), rhs: __v_57.as_canonical_u64(), msg: Some("canonical block: refinement left members tied, order ambiguous".to_string()) });
+                }
+                let __r_arr: [G; OUT_518] = { let __args: [G; IN_518] = [__v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[518].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_518] = unsafe { *(result.output.as_ptr() as *const [G; OUT_518]) }; __ret } else { aiur_fn_518(__args, record, io_buffer, __cu)? } };
+                let __v_58: G = __r_arr[0];
+                let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_58, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } else { aiur_fn_310(__args, record, io_buffer, __cu)? } };
+                let __v_59: G = __r_arr[0];
+                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: Some("canonical block: members are not in canonical order".to_string()) });
+                }
+                let __ret: [G; OUT_521] = [];
+                record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
+            let __ret: [G; OUT_521] = [];
+            record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
     }
   })
 }
 
-const INPUT_SIZE_607: usize = 3;
-const IN_607: usize = 3;
-const OUT_607: usize = 1;
-fn aiur_fn_607(
-  inp: [G; IN_607],
+const INPUT_SIZE_522: usize = 12;
+const IN_522: usize = 12;
+const OUT_522: usize = 1;
+fn aiur_fn_522(
+  inp: [G; IN_522],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_607], ExecError> {
+) -> Result<[G; OUT_522], 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; 6] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7]; 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_607] = [__v_8];
-        record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    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];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __ret: [G; OUT_522] = [__v_3];
+        record.function_queries[522].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-        let __v_6: G = __r_arr[0];
-        let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].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];
-        let __v_17: G = __loaded[10];
-        match __v_7.as_canonical_u64() {
-          5u64 => {
-            let __v_18: G = G::from_u64(0);
-            let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_1, __v_8, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[552].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_552] = unsafe { *(result.output.as_ptr() as *const [G; OUT_552]) }; __ret } else { aiur_fn_552(__args, record, io_buffer, __cu)? } };
-            let __v_19: G = __r_arr[0];
-            let __v_20: G = G::from_u64(0);
-            let __v_21: G = G::from_u64(0);
-            let __v_22: G = G::from_u64(1);
-            let __v_23: G = G::from_u64(1);
-            let __v_24: G = { let __values: [G; 3] = [__v_22, __v_23, __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 __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[607].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_607] = unsafe { *(result.output.as_ptr() as *const [G; OUT_607]) }; __ret } else { aiur_fn_607(__args, record, io_buffer, __cu)? } };
-            let __v_25: G = __r_arr[0];
-            let __v_26: G = { let __values: [G; 6] = [__v_20, __v_4, __v_21, __v_24, __v_19, __v_25]; 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_607] = [__v_26];
-            record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+      1u64 => {
+        match __v_4.as_canonical_u64() {
+          1u64 => {
+            let __v_12: G = G::from_u64(0);
+            let __ret: [G; OUT_522] = [__v_12];
+            record.function_queries[522].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __v_18: G = G::from_u64(0);
-            let __v_19: G = G::from_u64(0);
-            let __v_20: G = G::from_u64(1);
-            let __v_21: G = G::from_u64(1);
-            let __v_22: G = { let __values: [G; 3] = [__v_20, __v_21, __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 = G::from_u64(1);
-            let __v_24: G = G::from_u64(1);
-            let __v_25: G = { let __values: [G; 3] = [__v_23, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_607] = { let __args: [G; IN_607] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[607].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_607] = unsafe { *(result.output.as_ptr() as *const [G; OUT_607]) }; __ret } else { aiur_fn_607(__args, record, io_buffer, __cu)? } };
-            let __v_26: G = __r_arr[0];
-            let __v_27: G = { let __values: [G; 6] = [__v_18, __v_4, __v_19, __v_22, __v_25, __v_26]; 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_607] = [__v_27];
-            record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __v_12: G = G::from_u64(1);
+            let __ret: [G; OUT_522] = [__v_12];
+            record.function_queries[522].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
+      2u64 => {
+        let __v_12: G = G::from_u64(0);
+        let __ret: [G; OUT_522] = [__v_12];
+        record.function_queries[522].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      3u64 => {
+        let __ret: [G; OUT_522] = [__v_4];
+        record.function_queries[522].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      4u64 => {
+        let __v_12: G = G::from_u64(0);
+        let __ret: [G; OUT_522] = [__v_12];
+        record.function_queries[522].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      5u64 => {
+        let __ret: [G; OUT_522] = [__v_6];
+        record.function_queries[522].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      6u64 => {
+        let __ret: [G; OUT_522] = [__v_8];
+        record.function_queries[522].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      7u64 => {
+        let __ret: [G; OUT_522] = [__v_9];
+        record.function_queries[522].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
+        return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_608: usize = 1;
-const IN_608: usize = 1;
-const OUT_608: usize = 1;
-fn aiur_fn_608(
-  inp: [G; IN_608],
+const INPUT_SIZE_523: usize = 1;
+const IN_523: usize = 1;
+const OUT_523: usize = 1;
+fn aiur_fn_523(
+  inp: [G; IN_523],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_608], ExecError> {
+) -> Result<[G; OUT_523], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; 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: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
+    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];
-    let __v_5: G = __loaded[4];
-    let __v_6: G = __loaded[5];
     match __v_1.as_canonical_u64() {
+      0u64 => {
+        let __v_5: G = G::from_u64(1);
+        let __ret: [G; OUT_523] = [__v_5];
+        record.function_queries[523].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
       1u64 => {
-        let __v_7: G = G::from_u64(1);
-        let __v_8: G = G::from_u64(1);
-        let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __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_608] = [__v_9];
-        record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __v_5: G = G::from_u64(1);
+        let __ret: [G; OUT_523] = [__v_5];
+        record.function_queries[523].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __v_7: G = G::from_u64(0);
-        let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = unsafe { *(result.output.as_ptr() as *const [G; OUT_608]) }; __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } };
-        let __v_8: G = __r_arr[0];
-        let __v_9: G = { let __values: [G; 3] = [__v_7, __v_2, __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_608] = [__v_9];
-        record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+      2u64 => {
+        let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[258].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_258] = unsafe { *(result.output.as_ptr() as *const [G; OUT_258]) }; __ret } else { aiur_fn_258(__args, record, io_buffer, __cu)? } };
+        let __v_5: G = __r_arr[0];
+        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; 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: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].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];
+        let __v_13: G = __loaded[7];
+        let __v_14: G = __loaded[8];
+        let __v_15: G = __loaded[9];
+        let __v_16: G = __loaded[10];
+        let __v_17: G = __loaded[11];
+        let __v_18: G = G::from_u64(1);
+        let __r_arr: [G; OUT_522] = { let __args: [G; IN_522] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[522].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_522] = unsafe { *(result.output.as_ptr() as *const [G; OUT_522]) }; __ret } else { aiur_fn_522(__args, record, io_buffer, __cu)? } };
+        let __v_19: G = __r_arr[0];
+        let __v_20: G = (__v_18 - __v_19);
+        let __ret: [G; OUT_523] = [__v_20];
+        record.function_queries[523].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      3u64 => {
+        let __r_arr: [G; OUT_523] = { let __args: [G; IN_523] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[523].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_523] = unsafe { *(result.output.as_ptr() as *const [G; OUT_523]) }; __ret } else { aiur_fn_523(__args, record, io_buffer, __cu)? } };
+        let __v_5: G = __r_arr[0];
+        let __r_arr: [G; OUT_523] = { let __args: [G; IN_523] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[523].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_523] = unsafe { *(result.output.as_ptr() as *const [G; OUT_523]) }; __ret } else { aiur_fn_523(__args, record, io_buffer, __cu)? } };
+        let __v_6: G = __r_arr[0];
+        let __v_7: G = (__v_5 * __v_6);
+        let __ret: [G; OUT_523] = [__v_7];
+        record.function_queries[523].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      4u64 => {
+        let __r_arr: [G; OUT_523] = { let __args: [G; IN_523] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[523].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_523] = unsafe { *(result.output.as_ptr() as *const [G; OUT_523]) }; __ret } else { aiur_fn_523(__args, record, io_buffer, __cu)? } };
+        let __v_5: G = __r_arr[0];
+        let __r_arr: [G; OUT_523] = { let __args: [G; IN_523] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[523].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_523] = unsafe { *(result.output.as_ptr() as *const [G; OUT_523]) }; __ret } else { aiur_fn_523(__args, record, io_buffer, __cu)? } };
+        let __v_6: G = __r_arr[0];
+        let __v_7: G = (__v_5 * __v_6);
+        let __ret: [G; OUT_523] = [__v_7];
+        record.function_queries[523].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      5u64 => {
+        let __r_arr: [G; OUT_523] = { let __args: [G; IN_523] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[523].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_523] = unsafe { *(result.output.as_ptr() as *const [G; OUT_523]) }; __ret } else { aiur_fn_523(__args, record, io_buffer, __cu)? } };
+        let __v_5: G = __r_arr[0];
+        let __r_arr: [G; OUT_523] = { let __args: [G; IN_523] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[523].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_523] = unsafe { *(result.output.as_ptr() as *const [G; OUT_523]) }; __ret } else { aiur_fn_523(__args, record, io_buffer, __cu)? } };
+        let __v_6: G = __r_arr[0];
+        let __v_7: G = (__v_5 * __v_6);
+        let __ret: [G; OUT_523] = [__v_7];
+        record.function_queries[523].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      6u64 => {
+        let __r_arr: [G; OUT_523] = { let __args: [G; IN_523] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[523].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_523] = unsafe { *(result.output.as_ptr() as *const [G; OUT_523]) }; __ret } else { aiur_fn_523(__args, record, io_buffer, __cu)? } };
+        let __v_5: G = __r_arr[0];
+        let __r_arr: [G; OUT_523] = { let __args: [G; IN_523] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[523].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_523] = unsafe { *(result.output.as_ptr() as *const [G; OUT_523]) }; __ret } else { aiur_fn_523(__args, record, io_buffer, __cu)? } };
+        let __v_6: G = __r_arr[0];
+        let __r_arr: [G; OUT_523] = { let __args: [G; IN_523] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[523].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_523] = unsafe { *(result.output.as_ptr() as *const [G; OUT_523]) }; __ret } else { aiur_fn_523(__args, record, io_buffer, __cu)? } };
+        let __v_7: G = __r_arr[0];
+        let __v_8: G = (__v_6 * __v_7);
+        let __v_9: G = (__v_5 * __v_8);
+        let __ret: [G; OUT_523] = [__v_9];
+        record.function_queries[523].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      7u64 => {
+        let __v_5: G = G::from_u64(1);
+        let __ret: [G; OUT_523] = [__v_5];
+        record.function_queries[523].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      8u64 => {
+        let __r_arr: [G; OUT_523] = { let __args: [G; IN_523] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[523].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_523] = unsafe { *(result.output.as_ptr() as *const [G; OUT_523]) }; __ret } else { aiur_fn_523(__args, record, io_buffer, __cu)? } };
+        let __v_5: G = __r_arr[0];
+        let __ret: [G; OUT_523] = [__v_5];
+        record.function_queries[523].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -52031,875 +44136,898 @@ fn aiur_fn_608(
   })
 }
 
-const INPUT_SIZE_609: usize = 2;
-const IN_609: usize = 2;
-const OUT_609: usize = 4;
-fn aiur_fn_609(
-  inp: [G; IN_609],
+const INPUT_SIZE_524: usize = 2;
+const IN_524: usize = 2;
+const OUT_524: usize = 0;
+fn aiur_fn_524(
+  inp: [G; IN_524],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_609], ExecError> {
+) -> Result<[G; OUT_524], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; 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: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].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];
-    match __v_2.as_canonical_u64() {
+    match __v_0.as_canonical_u64() {
       1u64 => {
-        let __v_8: G = G::from_u64(0);
-        let __v_9: G = G::from_u64(0);
-        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 __v_13: G = G::from_u64(1);
-        let __v_14: G = G::from_u64(1);
-        let __v_15: G = { let __values: [G; 3] = [__v_13, __v_14, __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_609] = [__v_8, __v_9, __v_12, __v_15];
-        record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_524] = [];
+        record.function_queries[524].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        match __v_1.as_canonical_u64() {
-          0u64 => {
-            let __ret: [G; OUT_609] = [__v_3, __v_4, __v_5, __v_6];
-            record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            let __v_8: G = G::from_u64(1);
-            let __v_9: G = (__v_1 - __v_8);
-            let __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__v_7, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[609].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_609] = unsafe { *(result.output.as_ptr() as *const [G; OUT_609]) }; __ret } else { aiur_fn_609(__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 __ret: [G; OUT_609] = [__v_10, __v_11, __v_12, __v_13];
-            record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-        }
-      },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+        let __r_arr: [G; OUT_523] = { let __args: [G; IN_523] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[523].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_523] = unsafe { *(result.output.as_ptr() as *const [G; OUT_523]) }; __ret } else { aiur_fn_523(__args, record, io_buffer, __cu)? } };
+        let __v_2: G = __r_arr[0];
+        let __v_3: G = G::from_u64(1);
+        if (__v_2 != __v_3) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_2.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: Some("safe constant references an unsafe constant".to_string()) });
+        }
+        let __ret: [G; OUT_524] = [];
+        record.function_queries[524].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_610: usize = 4;
-const IN_610: usize = 4;
-const OUT_610: usize = 1;
-fn aiur_fn_610(
-  inp: [G; IN_610],
+const INPUT_SIZE_525: usize = 2;
+const IN_525: usize = 2;
+const OUT_525: usize = 0;
+fn aiur_fn_525(
+  inp: [G; IN_525],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_610], ExecError> {
+) -> Result<[G; OUT_525], 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_795] = { let __args: [G; IN_795] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[795].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_795] = unsafe { *(result.output.as_ptr() as *const [G; OUT_795]) }; __ret } else { aiur_fn_795(__args, record, io_buffer, __cu)? } };
-    let __v_4: G = __r_arr[0];
-    let __r_arr: [G; OUT_791] = { let __args: [G; IN_791] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[791].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_791] = unsafe { *(result.output.as_ptr() as *const [G; OUT_791]) }; __ret } else { aiur_fn_791(__args, record, io_buffer, __cu)? } };
-    let __v_5: G = __r_arr[0];
-    let __v_6: G = G::from_u64(0);
-    let __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[609].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_609] = unsafe { *(result.output.as_ptr() as *const [G; OUT_609]) }; __ret } else { aiur_fn_609(__args, record, io_buffer, __cu)? } };
-    let __v_7: G = __r_arr[0];
-    let __v_8: G = __r_arr[1];
-    let __v_9: G = __r_arr[2];
-    let __v_10: G = __r_arr[3];
-    let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-    let __v_11: G = __r_arr[0];
-    let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr };
-    let __v_12: G = __loaded[0];
-    let __v_13: G = __loaded[1];
-    let __v_14: G = __loaded[2];
-    let __v_15: G = __loaded[3];
-    let __v_16: G = __loaded[4];
-    let __v_17: G = __loaded[5];
-    let __v_18: G = __loaded[6];
-    let __v_19: G = __loaded[7];
-    let __v_20: G = __loaded[8];
-    let __v_21: G = __loaded[9];
-    let __v_22: G = __loaded[10];
-    match __v_12.as_canonical_u64() {
-      5u64 => {
-        let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[573].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_573] = unsafe { *(result.output.as_ptr() as *const [G; OUT_573]) }; __ret } else { aiur_fn_573(__args, record, io_buffer, __cu)? } };
-        let __v_23: G = __r_arr[0];
-        let __v_24: G = __r_arr[1];
-        let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { 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_25: G = __r_arr[0];
-        let __r_arr: [G; OUT_794] = { let __args: [G; IN_794] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[794].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_794] = unsafe { *(result.output.as_ptr() as *const [G; OUT_794]) }; __ret } else { aiur_fn_794(__args, record, io_buffer, __cu)? } };
-        let __v_26: G = __r_arr[0];
-        let __v_27: G = G::from_u64(0);
-        let __v_28: G = G::from_u64(0);
-        let __r_arr: [G; OUT_611] = { let __args: [G; IN_611] = [__v_28, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[611].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_611] = unsafe { *(result.output.as_ptr() as *const [G; OUT_611]) }; __ret } else { aiur_fn_611(__args, record, io_buffer, __cu)? } };
-        let __v_29: G = __r_arr[0];
-        let __v_30: G = G::from_u64(1);
-        let __v_31: G = G::from_u64(1);
-        let __v_32: G = { let __values: [G; 3] = [__v_30, __v_31, __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_27, __v_29, __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 = G::from_u64(1);
-        let __v_35: G = (__v_26 + __v_34);
-        let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_33, __v_5, __v_10, __v_15, __v_23, __v_25, __v_2, __v_3, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[613].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_613] = unsafe { *(result.output.as_ptr() as *const [G; OUT_613]) }; __ret } else { aiur_fn_613(__args, record, io_buffer, __cu)? } };
-        let __v_36: G = __r_arr[0];
-        let __r_arr: [G; OUT_692] = { let __args: [G; IN_692] = [__v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[692].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_692] = unsafe { *(result.output.as_ptr() as *const [G; OUT_692]) }; __ret } else { aiur_fn_692(__args, record, io_buffer, __cu)? } };
-        let __v_37: G = __r_arr[0];
-        let __r_arr: [G; OUT_612] = { let __args: [G; IN_612] = [__v_37, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[612].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_612] = unsafe { *(result.output.as_ptr() as *const [G; OUT_612]) }; __ret } else { aiur_fn_612(__args, record, io_buffer, __cu)? } };
-        let __v_38: G = __r_arr[0];
-        let __r_arr: [G; OUT_783] = { let __args: [G; IN_783] = [__v_4, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[783].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_783] = unsafe { *(result.output.as_ptr() as *const [G; OUT_783]) }; __ret } else { aiur_fn_783(__args, record, io_buffer, __cu)? } };
-        let __v_39: G = __r_arr[0];
-        let __ret: [G; OUT_610] = [__v_39];
-        record.function_queries[610].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_2: G = __loaded[0];
+    let __v_3: G = __loaded[1];
+    let __v_4: G = __loaded[2];
+    match __v_2.as_canonical_u64() {
+      0u64 => {
+        let __ret: [G; OUT_525] = [];
+        record.function_queries[525].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      _ => {
-        let __ret: [G; OUT_610] = [__v_0];
-        record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+      1u64 => {
+        let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } else { aiur_fn_525(__args, record, io_buffer, __cu)? } };
+        let __ret: [G; OUT_525] = [];
+        record.function_queries[525].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      2u64 => {
+        let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } else { aiur_fn_525(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } else { aiur_fn_525(__args, record, io_buffer, __cu)? } };
+        let __ret: [G; OUT_525] = [];
+        record.function_queries[525].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      3u64 => {
+        let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } else { aiur_fn_525(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } else { aiur_fn_525(__args, record, io_buffer, __cu)? } };
+        let __ret: [G; OUT_525] = [];
+        record.function_queries[525].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      4u64 => {
+        let __v_5: G = { let __a_val = __v_3.as_canonical_u64(); let __b_val = __v_1.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_6: G = G::from_u64(1);
+        if (__v_5 != __v_6) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: Some("universe param index out of range".to_string()) });
+        }
+        let __ret: [G; OUT_525] = [];
+        record.function_queries[525].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
     }
   })
 }
 
-const INPUT_SIZE_611: usize = 2;
-const IN_611: usize = 2;
-const OUT_611: usize = 1;
-fn aiur_fn_611(
-  inp: [G; IN_611],
+const INPUT_SIZE_526: usize = 2;
+const IN_526: usize = 2;
+const OUT_526: usize = 0;
+fn aiur_fn_526(
+  inp: [G; IN_526],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_611], ExecError> {
+) -> Result<[G; OUT_526], 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_1 - __v_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_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_526] = [];
+        record.function_queries[526].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
       0u64 => {
-        let __v_3: G = G::from_u64(1);
-        let __v_4: G = G::from_u64(1);
-        let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __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 __ret: [G; OUT_611] = [__v_5];
-        record.function_queries[611].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } else { aiur_fn_525(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[526].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_526] = unsafe { *(result.output.as_ptr() as *const [G; OUT_526]) }; __ret } else { aiur_fn_526(__args, record, io_buffer, __cu)? } };
+        let __ret: [G; OUT_526] = [];
+        record.function_queries[526].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(1);
-        let __v_5: G = (__v_0 + __v_4);
-        let __r_arr: [G; OUT_611] = { let __args: [G; IN_611] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[611].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_611] = unsafe { *(result.output.as_ptr() as *const [G; OUT_611]) }; __ret } else { aiur_fn_611(__args, record, io_buffer, __cu)? } };
-        let __v_6: G = __r_arr[0];
-        let __v_7: G = { let __values: [G; 3] = [__v_3, __v_0, __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_611] = [__v_7];
-        record.function_queries[611].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_612: usize = 2;
-const IN_612: usize = 2;
-const OUT_612: usize = 1;
-fn aiur_fn_612(
-  inp: [G; IN_612],
+const INPUT_SIZE_527: usize = 3;
+const IN_527: usize = 3;
+const OUT_527: usize = 0;
+fn aiur_fn_527(
+  inp: [G; IN_527],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_612], ExecError> {
+) -> Result<[G; OUT_527], 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() {
+    let __v_2: G = inp[2];
+    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_3: G = __loaded[0];
+    let __v_4: G = __loaded[1];
+    let __v_5: G = __loaded[2];
+    let __v_6: G = __loaded[3];
+    match __v_3.as_canonical_u64() {
+      0u64 => {
+        let __v_7: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_1.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_8: G = G::from_u64(1);
+        if (__v_7 != __v_8) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("loose bound variable: BVar index exceeds binder depth".to_string()) });
+        }
+        let __ret: [G; OUT_527] = [];
+        record.function_queries[527].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
       1u64 => {
-        let __v_5: G = G::from_u64(1);
-        let __v_6: G = G::from_u64(1);
-        let __v_7: G = { let __values: [G; 6] = [__v_5, __v_6, __v_6, __v_6, __v_6, __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_612] = [__v_7];
-        record.function_queries[612].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } else { aiur_fn_525(__args, record, io_buffer, __cu)? } };
+        let __ret: [G; OUT_527] = [];
+        record.function_queries[527].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __v_5: G = G::from_u64(0);
-        let __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[609].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_609] = unsafe { *(result.output.as_ptr() as *const [G; OUT_609]) }; __ret } else { aiur_fn_609(__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 __r_arr: [G; OUT_612] = { let __args: [G; IN_612] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[612].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_612] = unsafe { *(result.output.as_ptr() as *const [G; OUT_612]) }; __ret } else { aiur_fn_612(__args, record, io_buffer, __cu)? } };
-        let __v_10: G = __r_arr[0];
-        let __v_11: G = { let __values: [G; 6] = [__v_5, __v_6, __v_7, __v_8, __v_9, __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_612] = [__v_11];
-        record.function_queries[612].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+      2u64 => {
+        let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[258].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_258] = unsafe { *(result.output.as_ptr() as *const [G; OUT_258]) }; __ret } else { aiur_fn_258(__args, record, io_buffer, __cu)? } };
+        let __v_7: G = __r_arr[0];
+        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; 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: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].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];
+        let __v_18: G = __loaded[10];
+        let __v_19: G = __loaded[11];
+        let __r_arr: [G; OUT_386] = { let __args: [G; IN_386] = [__v_8, __v_9, __v_10, __v_11, __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[386].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_386] = unsafe { *(result.output.as_ptr() as *const [G; OUT_386]) }; __ret } else { aiur_fn_386(__args, record, io_buffer, __cu)? } };
+        let __v_20: G = __r_arr[0];
+        let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } else { aiur_fn_711(__args, record, io_buffer, __cu)? } };
+        let __v_21: G = __r_arr[0];
+        if (__v_21 != __v_20) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_21.as_canonical_u64(), rhs: __v_20.as_canonical_u64(), msg: Some("Const applied to wrong number of universe levels".to_string()) });
+        }
+        let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = [__v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[526].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_526] = unsafe { *(result.output.as_ptr() as *const [G; OUT_526]) }; __ret } else { aiur_fn_526(__args, record, io_buffer, __cu)? } };
+        let __ret: [G; OUT_527] = [];
+        record.function_queries[527].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      3u64 => {
+        let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } else { aiur_fn_527(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } else { aiur_fn_527(__args, record, io_buffer, __cu)? } };
+        let __ret: [G; OUT_527] = [];
+        record.function_queries[527].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      4u64 => {
+        let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } else { aiur_fn_527(__args, record, io_buffer, __cu)? } };
+        let __v_7: G = G::from_u64(1);
+        let __v_8: G = (__v_1 + __v_7);
+        let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } else { aiur_fn_527(__args, record, io_buffer, __cu)? } };
+        let __ret: [G; OUT_527] = [];
+        record.function_queries[527].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      5u64 => {
+        let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } else { aiur_fn_527(__args, record, io_buffer, __cu)? } };
+        let __v_7: G = G::from_u64(1);
+        let __v_8: G = (__v_1 + __v_7);
+        let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } else { aiur_fn_527(__args, record, io_buffer, __cu)? } };
+        let __ret: [G; OUT_527] = [];
+        record.function_queries[527].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      6u64 => {
+        let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } else { aiur_fn_527(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } else { aiur_fn_527(__args, record, io_buffer, __cu)? } };
+        let __v_7: G = G::from_u64(1);
+        let __v_8: G = (__v_1 + __v_7);
+        let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_6, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } else { aiur_fn_527(__args, record, io_buffer, __cu)? } };
+        let __ret: [G; OUT_527] = [];
+        record.function_queries[527].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      7u64 => {
+        let __ret: [G; OUT_527] = [];
+        record.function_queries[527].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      8u64 => {
+        let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } else { aiur_fn_527(__args, record, io_buffer, __cu)? } };
+        let __ret: [G; OUT_527] = [];
+        record.function_queries[527].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_613: usize = 9;
-const IN_613: usize = 9;
-const OUT_613: usize = 1;
-fn aiur_fn_613(
-  inp: [G; IN_613],
+const INPUT_SIZE_528: usize = 0;
+const IN_528: usize = 0;
+const OUT_528: usize = 1;
+fn aiur_fn_528(
+  inp: [G; IN_528],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_528], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = G::from_u64(171);
+    let __v_1: G = G::from_u64(104);
+    let __v_2: G = G::from_u64(44);
+    let __v_3: G = G::from_u64(23);
+    let __v_4: G = G::from_u64(120);
+    let __v_5: G = G::from_u64(161);
+    let __v_6: G = G::from_u64(123);
+    let __v_7: G = G::from_u64(190);
+    let __v_8: G = G::from_u64(174);
+    let __v_9: G = G::from_u64(64);
+    let __v_10: G = G::from_u64(50);
+    let __v_11: G = G::from_u64(151);
+    let __v_12: G = G::from_u64(77);
+    let __v_13: G = G::from_u64(243);
+    let __v_14: G = G::from_u64(100);
+    let __v_15: G = G::from_u64(71);
+    let __v_16: G = G::from_u64(206);
+    let __v_17: G = G::from_u64(139);
+    let __v_18: G = G::from_u64(252);
+    let __v_19: G = G::from_u64(171);
+    let __v_20: G = G::from_u64(103);
+    let __v_21: G = G::from_u64(100);
+    let __v_22: G = G::from_u64(163);
+    let __v_23: G = G::from_u64(109);
+    let __v_24: G = G::from_u64(55);
+    let __v_25: G = G::from_u64(133);
+    let __v_26: G = G::from_u64(102);
+    let __v_27: G = G::from_u64(227);
+    let __v_28: G = G::from_u64(173);
+    let __v_29: G = G::from_u64(99);
+    let __v_30: G = G::from_u64(202);
+    let __v_31: G = G::from_u64(184);
+    let __v_32: G = { let __values: [G; 32] = [__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]; 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_528] = [__v_32];
+    record.function_queries[528].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_529: usize = 0;
+const IN_529: usize = 0;
+const OUT_529: usize = 1;
+fn aiur_fn_529(
+  inp: [G; IN_529],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_529], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = G::from_u64(136);
+    let __v_1: G = G::from_u64(38);
+    let __v_2: G = G::from_u64(102);
+    let __v_3: G = G::from_u64(119);
+    let __v_4: G = G::from_u64(254);
+    let __v_5: G = G::from_u64(231);
+    let __v_6: G = G::from_u64(116);
+    let __v_7: G = G::from_u64(209);
+    let __v_8: G = G::from_u64(9);
+    let __v_9: G = G::from_u64(134);
+    let __v_10: G = G::from_u64(126);
+    let __v_11: G = G::from_u64(75);
+    let __v_12: G = G::from_u64(34);
+    let __v_13: G = G::from_u64(64);
+    let __v_14: G = G::from_u64(40);
+    let __v_15: G = G::from_u64(26);
+    let __v_16: G = G::from_u64(162);
+    let __v_17: G = G::from_u64(238);
+    let __v_18: G = G::from_u64(18);
+    let __v_19: G = G::from_u64(217);
+    let __v_20: G = G::from_u64(121);
+    let __v_21: G = G::from_u64(32);
+    let __v_22: G = G::from_u64(193);
+    let __v_23: G = G::from_u64(23);
+    let __v_24: G = G::from_u64(28);
+    let __v_25: G = G::from_u64(245);
+    let __v_26: G = G::from_u64(193);
+    let __v_27: G = G::from_u64(246);
+    let __v_28: G = G::from_u64(200);
+    let __v_29: G = G::from_u64(125);
+    let __v_30: G = G::from_u64(236);
+    let __v_31: G = G::from_u64(246);
+    let __v_32: G = { let __values: [G; 32] = [__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]; 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_529] = [__v_32];
+    record.function_queries[529].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_530: usize = 0;
+const IN_530: usize = 0;
+const OUT_530: usize = 1;
+fn aiur_fn_530(
+  inp: [G; IN_530],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_613], ExecError> {
+) -> Result<[G; OUT_530], 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];
-    match __v_8.as_canonical_u64() {
-      0u64 => {
-        let __ret: [G; OUT_613] = [__v_0];
-        record.function_queries[613].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        let __v_9: G = G::from_u64(0);
-        let __r_arr: [G; OUT_614] = { let __args: [G; IN_614] = [__v_0, __v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[614].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_614] = unsafe { *(result.output.as_ptr() as *const [G; OUT_614]) }; __ret } else { aiur_fn_614(__args, record, io_buffer, __cu)? } };
-        let __v_10: G = __r_arr[0];
-        let __r_arr: [G; OUT_616] = { let __args: [G; IN_616] = [__v_0, __v_10, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[616].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_616] = unsafe { *(result.output.as_ptr() as *const [G; OUT_616]) }; __ret } else { aiur_fn_616(__args, record, io_buffer, __cu)? } };
-        let __v_11: G = __r_arr[0];
-        let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[706].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_706] = unsafe { *(result.output.as_ptr() as *const [G; OUT_706]) }; __ret } else { aiur_fn_706(__args, record, io_buffer, __cu)? } };
-        let __v_12: G = __r_arr[0];
-        match __v_12.as_canonical_u64() {
-          1u64 => {
-            let __ret: [G; OUT_613] = [__v_0];
-            record.function_queries[613].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            let __v_13: G = G::from_u64(1);
-            let __v_14: G = (__v_8 - __v_13);
-            let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_11, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[613].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_613] = unsafe { *(result.output.as_ptr() as *const [G; OUT_613]) }; __ret } else { aiur_fn_613(__args, record, io_buffer, __cu)? } };
-            let __v_15: G = __r_arr[0];
-            let __ret: [G; OUT_613] = [__v_15];
-            record.function_queries[613].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-        }
-      },
-    }
+    let __v_0: G = G::from_u64(141);
+    let __v_1: G = G::from_u64(196);
+    let __v_2: G = G::from_u64(169);
+    let __v_3: G = G::from_u64(117);
+    let __v_4: G = G::from_u64(39);
+    let __v_5: G = G::from_u64(129);
+    let __v_6: G = G::from_u64(47);
+    let __v_7: G = G::from_u64(139);
+    let __v_8: G = G::from_u64(120);
+    let __v_9: G = G::from_u64(23);
+    let __v_10: G = G::from_u64(183);
+    let __v_11: G = G::from_u64(124);
+    let __v_12: G = G::from_u64(208);
+    let __v_13: G = G::from_u64(121);
+    let __v_14: G = G::from_u64(172);
+    let __v_15: G = G::from_u64(230);
+    let __v_16: G = G::from_u64(20);
+    let __v_17: G = G::from_u64(80);
+    let __v_18: G = G::from_u64(170);
+    let __v_19: G = G::from_u64(1);
+    let __v_20: G = G::from_u64(133);
+    let __v_21: G = G::from_u64(172);
+    let __v_22: G = G::from_u64(88);
+    let __v_23: G = G::from_u64(133);
+    let __v_24: G = G::from_u64(102);
+    let __v_25: G = G::from_u64(30);
+    let __v_26: G = G::from_u64(194);
+    let __v_27: G = G::from_u64(172);
+    let __v_28: G = G::from_u64(186);
+    let __v_29: G = G::from_u64(139);
+    let __v_30: G = G::from_u64(123);
+    let __v_31: G = G::from_u64(208);
+    let __v_32: G = { let __values: [G; 32] = [__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]; 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_530] = [__v_32];
+    record.function_queries[530].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_614: usize = 3;
-const IN_614: usize = 3;
-const OUT_614: usize = 1;
-fn aiur_fn_614(
-  inp: [G; IN_614],
+const INPUT_SIZE_531: usize = 0;
+const IN_531: usize = 0;
+const OUT_531: usize = 1;
+fn aiur_fn_531(
+  inp: [G; IN_531],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_614], ExecError> {
+) -> Result<[G; OUT_531], 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; 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_614] = [__v_8];
-        record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __r_arr: [G; OUT_615] = { let __args: [G; IN_615] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[615].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_615] = unsafe { *(result.output.as_ptr() as *const [G; OUT_615]) }; __ret } else { aiur_fn_615(__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_2 + __v_7);
-        let __r_arr: [G; OUT_614] = { let __args: [G; IN_614] = [__v_5, __v_1, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[614].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_614] = unsafe { *(result.output.as_ptr() as *const [G; OUT_614]) }; __ret } else { aiur_fn_614(__args, record, io_buffer, __cu)? } };
-        let __v_9: G = __r_arr[0];
-        let __r_arr: [G; OUT_787] = { let __args: [G; IN_787] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[787].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_787] = unsafe { *(result.output.as_ptr() as *const [G; OUT_787]) }; __ret } else { aiur_fn_787(__args, record, io_buffer, __cu)? } };
-        let __v_10: G = __r_arr[0];
-        let __ret: [G; OUT_614] = [__v_10];
-        record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
-      },
-    }
+    let __v_0: G = G::from_u64(18);
+    let __v_1: G = G::from_u64(73);
+    let __v_2: G = G::from_u64(132);
+    let __v_3: G = G::from_u64(188);
+    let __v_4: G = G::from_u64(185);
+    let __v_5: G = G::from_u64(82);
+    let __v_6: G = G::from_u64(8);
+    let __v_7: G = G::from_u64(160);
+    let __v_8: G = G::from_u64(243);
+    let __v_9: G = G::from_u64(11);
+    let __v_10: G = G::from_u64(182);
+    let __v_11: G = G::from_u64(157);
+    let __v_12: G = G::from_u64(103);
+    let __v_13: G = G::from_u64(54);
+    let __v_14: G = G::from_u64(211);
+    let __v_15: G = G::from_u64(213);
+    let __v_16: G = G::from_u64(148);
+    let __v_17: G = G::from_u64(4);
+    let __v_18: G = G::from_u64(225);
+    let __v_19: G = G::from_u64(21);
+    let __v_20: G = G::from_u64(226);
+    let __v_21: G = G::from_u64(32);
+    let __v_22: G = G::from_u64(32);
+    let __v_23: G = G::from_u64(67);
+    let __v_24: G = G::from_u64(253);
+    let __v_25: G = G::from_u64(163);
+    let __v_26: G = G::from_u64(211);
+    let __v_27: G = G::from_u64(78);
+    let __v_28: G = G::from_u64(1);
+    let __v_29: G = G::from_u64(176);
+    let __v_30: G = G::from_u64(173);
+    let __v_31: G = G::from_u64(22);
+    let __v_32: G = { let __values: [G; 32] = [__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]; 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_531] = [__v_32];
+    record.function_queries[531].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_615: usize = 3;
-const IN_615: usize = 3;
-const OUT_615: usize = 1;
-fn aiur_fn_615(
-  inp: [G; IN_615],
+const INPUT_SIZE_532: usize = 3;
+const IN_532: usize = 3;
+const OUT_532: usize = 1;
+fn aiur_fn_532(
+  inp: [G; IN_532],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_615], ExecError> {
+) -> Result<[G; OUT_532], 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];
+    let __v_3: G = (__v_1 - __v_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; 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_615] = [__v_8];
-        record.function_queries[615].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
       0u64 => {
-        let __v_6: G = G::from_u64(0);
-        let __v_7: G = (__v_1 + __v_4);
-        let __r_arr: [G; OUT_615] = { let __args: [G; IN_615] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[615].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_615] = unsafe { *(result.output.as_ptr() as *const [G; OUT_615]) }; __ret } else { aiur_fn_615(__args, record, io_buffer, __cu)? } };
-        let __v_8: G = __r_arr[0];
-        let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_2, __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_615] = [__v_9];
-        record.function_queries[615].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __v_4: G = G::from_u64(1);
+        let __ret: [G; OUT_532] = [__v_4];
+        record.function_queries[532].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
+        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_4: G = __loaded[0];
+        let __v_5: G = __loaded[1];
+        let __v_6: G = __loaded[2];
+        let __v_7: G = __loaded[3];
+        match __v_4.as_canonical_u64() {
+          5u64 => {
+            let __v_8: G = G::from_u64(1);
+            let __v_9: G = (__v_2 + __v_8);
+            let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_6, __v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } else { aiur_fn_532(__args, record, io_buffer, __cu)? } };
+            let __v_10: G = __r_arr[0];
+            let __ret: [G; OUT_532] = [__v_10];
+            record.function_queries[532].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            let __v_8: G = G::from_u64(0);
+            let __ret: [G; OUT_532] = [__v_8];
+            record.function_queries[532].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+        }
       },
     }
   })
 }
 
-const INPUT_SIZE_616: usize = 9;
-const IN_616: usize = 9;
-const OUT_616: usize = 1;
-fn aiur_fn_616(
-  inp: [G; IN_616],
+const INPUT_SIZE_533: usize = 0;
+const IN_533: usize = 0;
+const OUT_533: usize = 0;
+fn aiur_fn_533(
+  inp: [G; IN_533],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_616], ExecError> {
+) -> Result<[G; OUT_533], 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; 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_9: G = __loaded[0];
-    let __v_10: G = __loaded[1];
-    let __v_11: G = __loaded[2];
-    match __v_9.as_canonical_u64() {
-      1u64 => {
-        let __v_12: G = G::from_u64(1);
-        let __v_13: G = G::from_u64(1);
-        let __v_14: G = { let __values: [G; 3] = [__v_12, __v_13, __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 __ret: [G; OUT_616] = [__v_14];
-        record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __r_arr: [G; OUT_617] = { let __args: [G; IN_617] = [__v_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[617].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_617] = unsafe { *(result.output.as_ptr() as *const [G; OUT_617]) }; __ret } else { aiur_fn_617(__args, record, io_buffer, __cu)? } };
-        let __v_12: G = __r_arr[0];
-        let __r_arr: [G; OUT_616] = { let __args: [G; IN_616] = [__v_11, __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[616].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_616] = unsafe { *(result.output.as_ptr() as *const [G; OUT_616]) }; __ret } else { aiur_fn_616(__args, record, io_buffer, __cu)? } };
-        let __v_13: G = __r_arr[0];
-        let __r_arr: [G; OUT_773] = { let __args: [G; IN_773] = [__v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[773].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_773] = unsafe { *(result.output.as_ptr() as *const [G; OUT_773]) }; __ret } else { aiur_fn_773(__args, record, io_buffer, __cu)? } };
-        let __v_14: G = __r_arr[0];
-        let __ret: [G; OUT_616] = [__v_14];
-        record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __v_0: G = G::from_u64(3);
+    let __v_1: G = G::from_u64(107);
+    let __v_2: G = G::from_u64(99);
+    let __v_3: G = G::from_u64(213);
+    let __v_4: G = G::from_u64(204);
+    let __v_5: G = G::from_u64(9);
+    let __v_6: G = G::from_u64(97);
+    let __v_7: G = G::from_u64(233);
+    let __v_8: G = G::from_u64(32);
+    let __v_9: G = G::from_u64(222);
+    let __v_10: G = G::from_u64(229);
+    let __v_11: G = G::from_u64(14);
+    let __v_12: G = G::from_u64(115);
+    let __v_13: G = G::from_u64(100);
+    let __v_14: G = G::from_u64(236);
+    let __v_15: G = G::from_u64(13);
+    let __v_16: G = G::from_u64(211);
+    let __v_17: G = G::from_u64(249);
+    let __v_18: G = G::from_u64(195);
+    let __v_19: G = G::from_u64(138);
+    let __v_20: G = G::from_u64(156);
+    let __v_21: G = G::from_u64(172);
+    let __v_22: G = G::from_u64(228);
+    let __v_23: G = G::from_u64(14);
+    let __v_24: G = G::from_u64(81);
+    let __v_25: G = G::from_u64(59);
+    let __v_26: G = G::from_u64(56);
+    let __v_27: G = G::from_u64(53);
+    let __v_28: G = G::from_u64(222);
+    let __v_29: G = G::from_u64(200);
+    let __v_30: G = G::from_u64(224);
+    let __v_31: G = G::from_u64(201);
+    let __v_32: G = { let __values: [G; 32] = [__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]; 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_258] = { let __args: [G; IN_258] = [__v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[258].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_258] = unsafe { *(result.output.as_ptr() as *const [G; OUT_258]) }; __ret } else { aiur_fn_258(__args, record, io_buffer, __cu)? } };
+    let __v_33: G = __r_arr[0];
+    let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; 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: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].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];
+    match __v_34.as_canonical_u64() {
+      5u64 => {
+        let __v_46: G = G::from_u64(1);
+        if (__v_35 != __v_46) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_35.as_canonical_u64(), rhs: __v_46.as_canonical_u64(), msg: Some("Eq inductive: wrong universe param count".to_string()) });
+        }
+        let __v_47: G = G::from_u64(2);
+        if (__v_37 != __v_47) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_37.as_canonical_u64(), rhs: __v_47.as_canonical_u64(), msg: Some("Eq inductive: wrong parameter count".to_string()) });
+        }
+        let __v_48: G = G::from_u64(1);
+        if (__v_39 != __v_48) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_39.as_canonical_u64(), rhs: __v_48.as_canonical_u64(), msg: Some("Eq inductive: wrong constructor count".to_string()) });
+        }
+        let __ret: [G; OUT_533] = [];
+        record.function_queries[533].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64()));
+        return Err(ExecError::MatchNoCase(__v_34.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_617: usize = 9;
-const IN_617: usize = 9;
-const OUT_617: usize = 1;
-fn aiur_fn_617(
-  inp: [G; IN_617],
+const INPUT_SIZE_534: usize = 4;
+const IN_534: usize = 4;
+const OUT_534: usize = 0;
+fn aiur_fn_534(
+  inp: [G; IN_534],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_617], ExecError> {
+) -> Result<[G; OUT_534], 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_187] = { let __args: [G; IN_187] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { 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_9: G = __r_arr[0];
-    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_617] = [__v_12];
-        record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      1u64 => {
-        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 = { 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 __v_14: G = { let __values: [G; 3] = [__v_10, __v_0, __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 __ret: [G; OUT_617] = [__v_14];
-        record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        let __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__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[618].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_618] = unsafe { *(result.output.as_ptr() as *const [G; OUT_618]) }; __ret } else { aiur_fn_618(__args, record, io_buffer, __cu)? } };
-        let __v_10: G = __r_arr[0];
-        let __r_arr: [G; OUT_620] = { let __args: [G; IN_620] = [__v_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[620].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_620] = unsafe { *(result.output.as_ptr() as *const [G; OUT_620]) }; __ret } else { aiur_fn_620(__args, record, io_buffer, __cu)? } };
-        let __v_11: G = __r_arr[0];
-        let __ret: [G; OUT_617] = [__v_11];
-        record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
+    let __mc_out___mc_0: [G; 2] = '__mc_0: { match __v_1.as_canonical_u64() {
+  0u64 => {
+    let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } else { aiur_fn_528(__args, record, io_buffer, __cu)? } };
+    let __v_4: G = __r_arr[0];
+    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_5: G = __r_arr[0];
+    let __v_6: G = G::from_u64(1);
+    if (__v_5 != __v_6) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: Some("Quot.Typ declared at a non-canonical address".to_string()) });
     }
-  })
+    let __v_7: G = G::from_u64(1);
+    let __v_8: G = G::from_u64(2);
+    break '__mc_0 [__v_7, __v_8];
+  },
+  1u64 => {
+    let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } else { aiur_fn_529(__args, record, io_buffer, __cu)? } };
+    let __v_4: G = __r_arr[0];
+    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_5: G = __r_arr[0];
+    let __v_6: G = G::from_u64(1);
+    if (__v_5 != __v_6) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: Some("Quot.mk declared at a non-canonical address".to_string()) });
+    }
+    let __v_7: G = G::from_u64(1);
+    let __v_8: G = G::from_u64(3);
+    break '__mc_0 [__v_7, __v_8];
+  },
+  2u64 => {
+    let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } else { aiur_fn_533(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } else { aiur_fn_530(__args, record, io_buffer, __cu)? } };
+    let __v_4: G = __r_arr[0];
+    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_5: G = __r_arr[0];
+    let __v_6: G = G::from_u64(1);
+    if (__v_5 != __v_6) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: Some("Quot.lift declared at a non-canonical address".to_string()) });
+    }
+    let __v_7: G = G::from_u64(2);
+    let __v_8: G = G::from_u64(6);
+    break '__mc_0 [__v_7, __v_8];
+  },
+  3u64 => {
+    let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } else { aiur_fn_531(__args, record, io_buffer, __cu)? } };
+    let __v_4: G = __r_arr[0];
+    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_5: G = __r_arr[0];
+    let __v_6: G = G::from_u64(1);
+    if (__v_5 != __v_6) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: Some("Quot.ind declared at a non-canonical address".to_string()) });
+    }
+    let __v_7: G = G::from_u64(1);
+    let __v_8: G = G::from_u64(5);
+    break '__mc_0 [__v_7, __v_8];
+  },
+  _ => {
+    return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+  },
 }
-
-const INPUT_SIZE_618: usize = 9;
-const IN_618: usize = 9;
-const OUT_618: usize = 1;
-fn aiur_fn_618(
-  inp: [G; IN_618],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_618], 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; 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_9: G = __loaded[0];
-    let __v_10: G = __loaded[1];
-    let __v_11: G = __loaded[2];
-    match __v_9.as_canonical_u64() {
-      1u64 => {
-        let __v_12: G = G::from_u64(1);
-        let __v_13: G = G::from_u64(1);
-        let __v_14: G = { let __values: [G; 3] = [__v_12, __v_13, __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 __ret: [G; OUT_618] = [__v_14];
-        record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_11, __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[618].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_618] = unsafe { *(result.output.as_ptr() as *const [G; OUT_618]) }; __ret } else { aiur_fn_618(__args, record, io_buffer, __cu)? } };
-        let __v_12: G = __r_arr[0];
-        let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_10, __v_12, __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[619].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_619] = unsafe { *(result.output.as_ptr() as *const [G; OUT_619]) }; __ret } else { aiur_fn_619(__args, record, io_buffer, __cu)? } };
-        let __v_13: G = __r_arr[0];
-        let __ret: [G; OUT_618] = [__v_13];
-        record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64()));
-      },
+ };
+    let __v_4: G = __mc_out___mc_0[0];
+    let __v_5: G = __mc_out___mc_0[1];
+    if (__v_2 != __v_4) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_2.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("Quot constant: wrong universe param count for its kind".to_string()) });
     }
+    let __v_6: G = G::from_u64(0);
+    let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_3, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } else { aiur_fn_532(__args, record, io_buffer, __cu)? } };
+    let __v_7: G = __r_arr[0];
+    let __v_8: G = G::from_u64(1);
+    if (__v_7 != __v_8) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("Quot constant: type has too few foralls for its kind".to_string()) });
+    }
+    let __ret: [G; OUT_534] = [];
+    record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_619: usize = 10;
-const IN_619: usize = 10;
-const OUT_619: usize = 1;
-fn aiur_fn_619(
-  inp: [G; IN_619],
+const INPUT_SIZE_535: usize = 2;
+const IN_535: usize = 2;
+const OUT_535: usize = 1;
+fn aiur_fn_535(
+  inp: [G; IN_535],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_619], ExecError> {
+) -> Result<[G; OUT_535], 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 __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_10: G = __loaded[0];
-    let __v_11: G = __loaded[1];
-    let __v_12: G = __loaded[2];
-    match __v_10.as_canonical_u64() {
-      1u64 => {
-        let __v_13: G = G::from_u64(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 __v_17: G = { let __values: [G; 3] = [__v_13, __v_0, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_619] = [__v_17];
-        record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    match __v_1.as_canonical_u64() {
+      0u64 => {
+        let __ret: [G; OUT_535] = [__v_0];
+        record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __r_arr: [G; OUT_622] = { let __args: [G; IN_622] = [__v_0, __v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[622].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_622] = unsafe { *(result.output.as_ptr() as *const [G; OUT_622]) }; __ret } else { aiur_fn_622(__args, record, io_buffer, __cu)? } };
-        let __v_13: G = __r_arr[0];
-        let __v_14: G = __r_arr[1];
-        match __v_13.as_canonical_u64() {
-          2u64 => {
-            let __v_15: G = G::from_u64(0);
-            let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_0, __v_12, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[619].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_619] = unsafe { *(result.output.as_ptr() as *const [G; OUT_619]) }; __ret } else { aiur_fn_619(__args, record, io_buffer, __cu)? } };
-            let __v_16: G = __r_arr[0];
-            let __v_17: G = { let __values: [G; 3] = [__v_15, __v_11, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_619] = [__v_17];
-            record.function_queries[619].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() {
+          5u64 => {
+            let __v_6: G = G::from_u64(1);
+            let __v_7: G = (__v_1 - __v_6);
+            let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } else { aiur_fn_535(__args, record, io_buffer, __cu)? } };
+            let __v_8: G = __r_arr[0];
+            let __ret: [G; OUT_535] = [__v_8];
+            record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __v_15: G = G::from_u64(0);
-            let __v_16: G = { let __values: [G; 3] = [__v_15, __v_0, __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_619] = [__v_16];
-            record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
+            return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64()));
-      },
     }
   })
 }
 
-const INPUT_SIZE_620: usize = 9;
-const IN_620: usize = 9;
-const OUT_620: usize = 1;
-fn aiur_fn_620(
-  inp: [G; IN_620],
+const INPUT_SIZE_536: usize = 3;
+const IN_536: usize = 3;
+const OUT_536: usize = 0;
+fn aiur_fn_536(
+  inp: [G; IN_536],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_620], ExecError> {
+) -> Result<[G; OUT_536], 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; 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_9: G = __loaded[0];
-    let __v_10: G = __loaded[1];
-    let __v_11: G = __loaded[2];
-    match __v_9.as_canonical_u64() {
-      1u64 => {
-        let __v_12: G = G::from_u64(1);
-        let __v_13: G = G::from_u64(1);
-        let __v_14: G = { let __values: [G; 3] = [__v_12, __v_13, __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 __ret: [G; OUT_620] = [__v_14];
-        record.function_queries[620].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
+    match __v_1.as_canonical_u64() {
       0u64 => {
-        let __v_12: G = G::from_u64(0);
-        let __v_13: G = G::from_u64(1);
-        let __v_14: G = G::from_u64(1);
-        let __v_15: G = { let __values: [G; 3] = [__v_13, __v_14, __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 __v_16: G = { let __values: [G; 3] = [__v_12, __v_10, __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_621] = { let __args: [G; IN_621] = [__v_11, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[621].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_621] = unsafe { *(result.output.as_ptr() as *const [G; OUT_621]) }; __ret } else { aiur_fn_621(__args, record, io_buffer, __cu)? } };
-        let __v_17: G = __r_arr[0];
-        let __ret: [G; OUT_620] = [__v_17];
-        record.function_queries[620].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } else { aiur_fn_711(__args, record, io_buffer, __cu)? } };
+        let __v_3: G = __r_arr[0];
+        let __v_4: G = G::from_u64(0);
+        if (__v_3 != __v_4) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("more universe levels than the inductive declares".to_string()) });
+        }
+        let __ret: [G; OUT_536] = [];
+        record.function_queries[536].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64()));
+        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() {
+          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_6: G = __loaded[0];
+            let __v_7: G = __loaded[1];
+            let __v_8: G = __loaded[2];
+            match __v_6.as_canonical_u64() {
+              4u64 => {
+                let __v_9: G = G::from_u64(1);
+                let __v_10: G = (__v_1 - __v_9);
+                let __v_11: G = G::from_u64(1);
+                let __v_12: G = (__v_2 + __v_11);
+                let __r_arr: [G; OUT_536] = { let __args: [G; IN_536] = [__v_5, __v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[536].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_536] = unsafe { *(result.output.as_ptr() as *const [G; OUT_536]) }; __ret } else { aiur_fn_536(__args, record, io_buffer, __cu)? } };
+                if (__v_7 != __v_2) {
+                  return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("ctor return type: universe level is not Param(i) in order".to_string()) });
+                }
+                let __ret: [G; OUT_536] = [];
+                record.function_queries[536].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_621: usize = 11;
-const IN_621: usize = 11;
-const OUT_621: usize = 1;
-fn aiur_fn_621(
-  inp: [G; IN_621],
+const INPUT_SIZE_537: usize = 4;
+const IN_537: usize = 4;
+const OUT_537: usize = 0;
+fn aiur_fn_537(
+  inp: [G; IN_537],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_621], ExecError> {
+) -> Result<[G; OUT_537], 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 __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_11: G = __loaded[0];
-    let __v_12: G = __loaded[1];
-    let __v_13: G = __loaded[2];
-    match __v_11.as_canonical_u64() {
-      1u64 => {
-        let __v_14: G = G::from_u64(0);
-        let __v_15: G = G::from_u64(1);
-        let __v_16: G = G::from_u64(1);
-        let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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_14, __v_10, __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 __ret: [G; OUT_621] = [__v_18];
-        record.function_queries[621].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __v_4: G = (__v_1 - __v_3);
+    match __v_4.as_canonical_u64() {
+      0u64 => {
+        let __ret: [G; OUT_537] = [];
+        record.function_queries[537].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __r_arr: [G; OUT_622] = { let __args: [G; IN_622] = [__v_9, __v_12, __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[622].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_622] = unsafe { *(result.output.as_ptr() as *const [G; OUT_622]) }; __ret } else { aiur_fn_622(__args, record, io_buffer, __cu)? } };
-        let __v_14: G = __r_arr[0];
-        let __v_15: G = __r_arr[1];
-        match __v_14.as_canonical_u64() {
-          1u64 => {
-            let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
-            let __v_16: G = __r_arr[0];
-            let __r_arr: [G; OUT_621] = { let __args: [G; IN_621] = [__v_13, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_12, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[621].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_621] = unsafe { *(result.output.as_ptr() as *const [G; OUT_621]) }; __ret } else { aiur_fn_621(__args, record, io_buffer, __cu)? } };
-            let __v_17: G = __r_arr[0];
-            let __ret: [G; OUT_621] = [__v_17];
-            record.function_queries[621].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_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; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; 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: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].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];
+            match __v_8.as_canonical_u64() {
+              0u64 => {
+                let __v_12: G = G::from_u64(1);
+                let __v_13: G = (__v_3 + __v_12);
+                let __r_arr: [G; OUT_537] = { let __args: [G; IN_537] = [__v_7, __v_1, __v_2, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[537].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_537] = unsafe { *(result.output.as_ptr() as *const [G; OUT_537]) }; __ret } else { aiur_fn_537(__args, record, io_buffer, __cu)? } };
+                let __v_14: G = (__v_2 + __v_1);
+                let __v_15: G = G::from_u64(1);
+                let __v_16: G = (__v_14 - __v_15);
+                let __v_17: G = (__v_16 - __v_3);
+                if (__v_9 != __v_17) {
+                  return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_17.as_canonical_u64(), msg: Some("ctor return type: param arg is not the expected param BVar".to_string()) });
+                }
+                let __ret: [G; OUT_537] = [];
+                record.function_queries[537].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64()));
+              },
+            }
           },
           _ => {
-            let __v_16: G = G::from_u64(0);
-            let __v_17: G = G::from_u64(0);
-            let __v_18: G = G::from_u64(1);
-            let __v_19: G = G::from_u64(1);
-            let __v_20: G = { let __values: [G; 3] = [__v_18, __v_19, __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_17, __v_12, __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 __r_arr: [G; OUT_621] = { let __args: [G; IN_621] = [__v_13, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_12, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[621].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_621] = unsafe { *(result.output.as_ptr() as *const [G; OUT_621]) }; __ret } else { aiur_fn_621(__args, record, io_buffer, __cu)? } };
-            let __v_22: G = __r_arr[0];
-            let __v_23: G = { let __values: [G; 3] = [__v_16, __v_10, __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_621] = [__v_23];
-            record.function_queries[621].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
+            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64()));
-      },
     }
   })
 }
 
-const INPUT_SIZE_622: usize = 10;
-const IN_622: usize = 10;
-const OUT_622: usize = 2;
-fn aiur_fn_622(
-  inp: [G; IN_622],
+const INPUT_SIZE_538: usize = 3;
+const IN_538: usize = 3;
+const OUT_538: usize = 0;
+fn aiur_fn_538(
+  inp: [G; IN_538],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_622], ExecError> {
+) -> Result<[G; OUT_538], 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 __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__v_3, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[609].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_609] = unsafe { *(result.output.as_ptr() as *const [G; OUT_609]) }; __ret } else { aiur_fn_609(__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 __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[609].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_609] = unsafe { *(result.output.as_ptr() as *const [G; OUT_609]) }; __ret } else { aiur_fn_609(__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 __v_17: G = __r_arr[3];
-    let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-    let __v_18: G = __r_arr[0];
-    let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].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 __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_8, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-    let __v_30: G = __r_arr[0];
-    let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr };
-    let __v_31: G = __loaded[0];
-    let __v_32: G = __loaded[1];
-    let __v_33: G = __loaded[2];
-    let __v_34: G = __loaded[3];
-    let __v_35: G = __loaded[4];
-    let __v_36: G = __loaded[5];
-    let __v_37: G = __loaded[6];
-    let __v_38: G = __loaded[7];
-    let __v_39: G = __loaded[8];
-    let __v_40: G = __loaded[9];
-    let __v_41: G = __loaded[10];
-    match __v_19.as_canonical_u64() {
+    let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[258].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_258] = unsafe { *(result.output.as_ptr() as *const [G; OUT_258]) }; __ret } else { aiur_fn_258(__args, record, io_buffer, __cu)? } };
+    let __v_3: G = __r_arr[0];
+    let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; 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: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+    let __v_4: G = __loaded[0];
+    let __v_5: G = __loaded[1];
+    let __v_6: G = __loaded[2];
+    let __v_7: G = __loaded[3];
+    let __v_8: G = __loaded[4];
+    let __v_9: G = __loaded[5];
+    let __v_10: G = __loaded[6];
+    let __v_11: G = __loaded[7];
+    let __v_12: G = __loaded[8];
+    let __v_13: G = __loaded[9];
+    let __v_14: G = __loaded[10];
+    let __v_15: G = __loaded[11];
+    match __v_4.as_canonical_u64() {
       5u64 => {
-        match __v_31.as_canonical_u64() {
-          5u64 => {
-            let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_23, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = unsafe { *(result.output.as_ptr() as *const [G; OUT_654]) }; __ret } else { aiur_fn_654(__args, record, io_buffer, __cu)? } };
-            let __v_42: G = __r_arr[0];
-            let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } };
-            let __v_43: G = __r_arr[0];
-            let __v_44: G = __r_arr[1];
-            let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { 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_45: G = __r_arr[0];
-            let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { 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_46: G = __r_arr[0];
-            let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_45, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = unsafe { *(result.output.as_ptr() as *const [G; OUT_654]) }; __ret } else { aiur_fn_654(__args, record, io_buffer, __cu)? } };
-            let __v_47: G = __r_arr[0];
-            let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } };
-            let __v_48: G = __r_arr[0];
-            let __v_49: G = __r_arr[1];
-            let __r_arr: [G; OUT_624] = { let __args: [G; IN_624] = [__v_21, __v_22, __v_12, __v_13, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[624].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_624] = unsafe { *(result.output.as_ptr() as *const [G; OUT_624]) }; __ret } else { aiur_fn_624(__args, record, io_buffer, __cu)? } };
-            let __v_50: G = __r_arr[0];
-            let __r_arr: [G; OUT_624] = { let __args: [G; IN_624] = [__v_33, __v_34, __v_16, __v_17, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[624].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_624] = unsafe { *(result.output.as_ptr() as *const [G; OUT_624]) }; __ret } else { aiur_fn_624(__args, record, io_buffer, __cu)? } };
-            let __v_51: G = __r_arr[0];
-            let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_50, __v_51, __v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[670].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_670] = unsafe { *(result.output.as_ptr() as *const [G; OUT_670]) }; __ret } else { aiur_fn_670(__args, record, io_buffer, __cu)? } };
-            let __v_52: G = __r_arr[0];
-            let __v_53: G = __r_arr[1];
-            let __r_arr: [G; OUT_625] = { let __args: [G; IN_625] = [__v_24, __v_22, __v_12, __v_13, __v_36, __v_34, __v_16, __v_17, __v_3, __v_4, __v_5, __v_6, __v_7, __v_2, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[625].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_625] = unsafe { *(result.output.as_ptr() as *const [G; OUT_625]) }; __ret } else { aiur_fn_625(__args, record, io_buffer, __cu)? } };
-            let __v_54: G = __r_arr[0];
-            let __v_55: G = __r_arr[1];
-            let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_10, __v_13, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[623].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_623] = unsafe { *(result.output.as_ptr() as *const [G; OUT_623]) }; __ret } else { aiur_fn_623(__args, record, io_buffer, __cu)? } };
-            let __v_56: G = __r_arr[0];
-            let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_14, __v_17, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[623].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_623] = unsafe { *(result.output.as_ptr() as *const [G; OUT_623]) }; __ret } else { aiur_fn_623(__args, record, io_buffer, __cu)? } };
-            let __v_57: G = __r_arr[0];
-            let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_56, __v_57, __v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[670].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_670] = unsafe { *(result.output.as_ptr() as *const [G; OUT_670]) }; __ret } else { aiur_fn_670(__args, record, io_buffer, __cu)? } };
-            let __v_58: G = __r_arr[0];
-            let __v_59: G = __r_arr[1];
-            let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_54, __v_55, __v_58, __v_59]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } };
-            let __v_60: G = __r_arr[0];
-            let __v_61: G = __r_arr[1];
-            let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_52, __v_53, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } };
-            let __v_62: G = __r_arr[0];
-            let __v_63: G = __r_arr[1];
-            let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_48, __v_49, __v_62, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } };
-            let __v_64: G = __r_arr[0];
-            let __v_65: G = __r_arr[1];
-            let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_43, __v_44, __v_64, __v_65]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } };
-            let __v_66: G = __r_arr[0];
-            let __v_67: G = __r_arr[1];
-            let __ret: [G; OUT_622] = [__v_66, __v_67];
-            record.function_queries[622].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[657].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_657] = unsafe { *(result.output.as_ptr() as *const [G; OUT_657]) }; __ret } else { aiur_fn_657(__args, record, io_buffer, __cu)? } };
-            let __v_42: G = __r_arr[0];
-            let __v_43: G = __r_arr[1];
-            let __ret: [G; OUT_622] = [__v_42, __v_43];
-            record.function_queries[622].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
+        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_16: G = __r_arr[0];
+        let __v_17: G = G::from_u64(1);
+        if (__v_16 != __v_17) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_17.as_canonical_u64(), msg: Some("ctor return head belongs to a different block".to_string()) });
+        }
+        if (__v_12 != __v_2) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_12.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("ctor return head is a different member of the block".to_string()) });
         }
+        let __ret: [G; OUT_538] = [];
+        record.function_queries[538].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[657].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_657] = unsafe { *(result.output.as_ptr() as *const [G; OUT_657]) }; __ret } else { aiur_fn_657(__args, record, io_buffer, __cu)? } };
-        let __v_42: G = __r_arr[0];
-        let __v_43: G = __r_arr[1];
-        let __ret: [G; OUT_622] = [__v_42, __v_43];
-        record.function_queries[622].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
+        return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_623: usize = 3;
-const IN_623: usize = 3;
-const OUT_623: usize = 1;
-fn aiur_fn_623(
-  inp: [G; IN_623],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_623], 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 = G::from_u64(2);
-    let __v_4: G = G::from_u64(0);
-    let __v_5: G = { let __values: [G; 4] = [__v_3, __v_0, __v_1, __v_4]; 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_427] = { let __args: [G; IN_427] = [__v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[427].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_427] = unsafe { *(result.output.as_ptr() as *const [G; OUT_427]) }; __ret } else { aiur_fn_427(__args, record, io_buffer, __cu)? } };
-    let __v_6: G = __r_arr[0];
-    let __ret: [G; OUT_623] = [__v_6];
-    record.function_queries[623].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_624: usize = 11;
-const IN_624: usize = 11;
-const OUT_624: usize = 1;
-fn aiur_fn_624(
-  inp: [G; IN_624],
+const INPUT_SIZE_539: usize = 7;
+const IN_539: usize = 7;
+const OUT_539: usize = 0;
+fn aiur_fn_539(
+  inp: [G; IN_539],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_624], ExecError> {
+) -> Result<[G; OUT_539], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -52908,303 +45036,194 @@ fn aiur_fn_624(
     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 __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } };
-    let __v_11: G = __r_arr[0];
-    let __v_12: G = G::from_u64(0);
-    let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_11, __v_1, __v_2, __v_12, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } else { aiur_fn_646(__args, record, io_buffer, __cu)? } };
-    let __v_13: G = __r_arr[0];
-    let __v_14: G = G::from_u64(0);
-    let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_13, __v_4, __v_5, __v_6, __v_8, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } else { aiur_fn_627(__args, record, io_buffer, __cu)? } };
-    let __v_15: G = __r_arr[0];
-    let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_15, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[555].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_555] = unsafe { *(result.output.as_ptr() as *const [G; OUT_555]) }; __ret } else { aiur_fn_555(__args, record, io_buffer, __cu)? } };
-    let __v_16: G = __r_arr[0];
-    let __ret: [G; OUT_624] = [__v_16];
-    record.function_queries[624].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
+    let __v_7: G = (__v_1 + __v_3);
+    let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } else { aiur_fn_535(__args, record, io_buffer, __cu)? } };
+    let __v_8: G = __r_arr[0];
+    let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[106].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_106] = unsafe { *(result.output.as_ptr() as *const [G; OUT_106]) }; __ret } else { aiur_fn_106(__args, record, io_buffer, __cu)? } };
+    let __v_9: G = __r_arr[0];
+    let __v_10: G = __r_arr[1];
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; 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: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].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];
+    match __v_11.as_canonical_u64() {
+      2u64 => {
+        let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_12, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[538].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_538] = unsafe { *(result.output.as_ptr() as *const [G; OUT_538]) }; __ret } else { aiur_fn_538(__args, record, io_buffer, __cu)? } };
+        let __v_15: G = G::from_u64(0);
+        let __r_arr: [G; OUT_536] = { let __args: [G; IN_536] = [__v_13, __v_4, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[536].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_536] = unsafe { *(result.output.as_ptr() as *const [G; OUT_536]) }; __ret } else { aiur_fn_536(__args, record, io_buffer, __cu)? } };
+        let __v_16: G = G::from_u64(0);
+        let __r_arr: [G; OUT_537] = { let __args: [G; IN_537] = [__v_10, __v_1, __v_3, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[537].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_537] = unsafe { *(result.output.as_ptr() as *const [G; OUT_537]) }; __ret } else { aiur_fn_537(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_10, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } };
+        let __v_17: G = __r_arr[0];
+        let __v_18: G = G::from_u64(0);
+        let __v_19: G = G::from_u64(1);
+        let __v_20: G = G::from_u64(1);
+        let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __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_18, __v_5, __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 __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } else { aiur_fn_711(__args, record, io_buffer, __cu)? } };
+        let __v_23: G = __r_arr[0];
+        let __v_24: G = (__v_1 + __v_2);
+        if (__v_23 != __v_24) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_23.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: Some("ctor return type: wrong number of spine arguments".to_string()) });
+        }
+        let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_17, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[550].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_550] = unsafe { *(result.output.as_ptr() as *const [G; OUT_550]) }; __ret } else { aiur_fn_550(__args, record, io_buffer, __cu)? } };
+        let __v_25: G = __r_arr[0];
+        let __v_26: G = G::from_u64(0);
+        if (__v_25 != __v_26) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_25.as_canonical_u64(), rhs: __v_26.as_canonical_u64(), msg: Some("ctor return type: reflexive occurrence in an index argument".to_string()) });
+        }
+        let __ret: [G; OUT_539] = [];
+        record.function_queries[539].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64()));
+      },
+    }
   })
 }
 
-const INPUT_SIZE_625: usize = 16;
-const IN_625: usize = 16;
-const OUT_625: usize = 2;
-fn aiur_fn_625(
-  inp: [G; IN_625],
+const INPUT_SIZE_540: usize = 4;
+const IN_540: usize = 4;
+const OUT_540: usize = 0;
+fn aiur_fn_540(
+  inp: [G; IN_540],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_625], ExecError> {
+) -> Result<[G; OUT_540], 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 __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_16: G = __loaded[0];
-    let __v_17: G = __loaded[1];
-    let __v_18: G = __loaded[2];
-    match __v_16.as_canonical_u64() {
-      1u64 => {
-        let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[657].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_657] = unsafe { *(result.output.as_ptr() as *const [G; OUT_657]) }; __ret } else { aiur_fn_657(__args, record, io_buffer, __cu)? } };
-        let __v_19: G = __r_arr[0];
-        let __v_20: G = __r_arr[1];
-        let __ret: [G; OUT_625] = [__v_19, __v_20];
-        record.function_queries[625].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    match __v_2.as_canonical_u64() {
+      0u64 => {
+        let __ret: [G; OUT_540] = [];
+        record.function_queries[540].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_19: G = __loaded[0];
-        let __v_20: G = __loaded[1];
-        let __v_21: G = __loaded[2];
-        match __v_19.as_canonical_u64() {
-          1u64 => {
-            let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[657].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_657] = unsafe { *(result.output.as_ptr() as *const [G; OUT_657]) }; __ret } else { aiur_fn_657(__args, record, io_buffer, __cu)? } };
-            let __v_22: G = __r_arr[0];
-            let __v_23: G = __r_arr[1];
-            let __ret: [G; OUT_625] = [__v_22, __v_23];
-            record.function_queries[625].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          0u64 => {
-            let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_14, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-            let __v_22: G = __r_arr[0];
-            let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr };
-            let __v_23: G = __loaded[0];
-            let __v_24: G = __loaded[1];
-            let __v_25: G = __loaded[2];
-            let __v_26: G = __loaded[3];
-            let __v_27: G = __loaded[4];
-            let __v_28: G = __loaded[5];
-            let __v_29: G = __loaded[6];
-            let __v_30: G = __loaded[7];
-            let __v_31: G = __loaded[8];
-            let __v_32: G = __loaded[9];
-            let __v_33: G = __loaded[10];
-            let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_14, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-            let __v_34: G = __r_arr[0];
-            let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_34.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].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];
-            match __v_23.as_canonical_u64() {
-              6u64 => {
-                match __v_35.as_canonical_u64() {
-                  6u64 => {
-                    let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_29, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = unsafe { *(result.output.as_ptr() as *const [G; OUT_654]) }; __ret } else { aiur_fn_654(__args, record, io_buffer, __cu)? } };
-                    let __v_46: G = __r_arr[0];
-                    let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } };
-                    let __v_47: G = __r_arr[0];
-                    let __v_48: G = __r_arr[1];
-                    let __r_arr: [G; OUT_626] = { let __args: [G; IN_626] = [__v_25, __v_1, __v_2, __v_3, __v_8, __v_9, __v_10, __v_11, __v_12, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[626].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_626] = unsafe { *(result.output.as_ptr() as *const [G; OUT_626]) }; __ret } else { aiur_fn_626(__args, record, io_buffer, __cu)? } };
-                    let __v_49: G = __r_arr[0];
-                    let __r_arr: [G; OUT_626] = { let __args: [G; IN_626] = [__v_37, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[626].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_626] = unsafe { *(result.output.as_ptr() as *const [G; OUT_626]) }; __ret } else { aiur_fn_626(__args, record, io_buffer, __cu)? } };
-                    let __v_50: G = __r_arr[0];
-                    let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_49, __v_50, __v_13, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[670].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_670] = unsafe { *(result.output.as_ptr() as *const [G; OUT_670]) }; __ret } else { aiur_fn_670(__args, record, io_buffer, __cu)? } };
-                    let __v_51: G = __r_arr[0];
-                    let __v_52: G = __r_arr[1];
-                    let __r_arr: [G; OUT_625] = { let __args: [G; IN_625] = [__v_18, __v_1, __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]; let __cu = unconstrained; if let Some(result) = record.function_queries[625].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_625] = unsafe { *(result.output.as_ptr() as *const [G; OUT_625]) }; __ret } else { aiur_fn_625(__args, record, io_buffer, __cu)? } };
-                    let __v_53: G = __r_arr[0];
-                    let __v_54: G = __r_arr[1];
-                    let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_51, __v_52, __v_53, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } };
-                    let __v_55: G = __r_arr[0];
-                    let __v_56: G = __r_arr[1];
-                    let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_47, __v_48, __v_55, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } };
-                    let __v_57: G = __r_arr[0];
-                    let __v_58: G = __r_arr[1];
-                    let __ret: [G; OUT_625] = [__v_57, __v_58];
-                    record.function_queries[625].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
-                  _ => {
-                    let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[657].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_657] = unsafe { *(result.output.as_ptr() as *const [G; OUT_657]) }; __ret } else { aiur_fn_657(__args, record, io_buffer, __cu)? } };
-                    let __v_46: G = __r_arr[0];
-                    let __v_47: G = __r_arr[1];
-                    let __ret: [G; OUT_625] = [__v_46, __v_47];
-                    record.function_queries[625].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
+      _ => {
+        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_4: G = __loaded[0];
+        let __v_5: G = __loaded[1];
+        let __v_6: G = __loaded[2];
+        let __v_7: G = __loaded[3];
+        match __v_4.as_canonical_u64() {
+          5u64 => {
+            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_8: G = __loaded[0];
+            let __v_9: G = __loaded[1];
+            let __v_10: G = __loaded[2];
+            let __v_11: G = __loaded[3];
+            match __v_8.as_canonical_u64() {
+              5u64 => {
+                let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_5, __v_9, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } };
+                let __v_12: G = __r_arr[0];
+                let __v_13: G = G::from_u64(0);
+                let __v_14: G = { let __values: [G; 3] = [__v_13, __v_5, __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 __v_15: G = G::from_u64(1);
+                if (__v_12 != __v_15) {
+                  return Err(ExecError::AssertEqMismatch { lhs: __v_12.as_canonical_u64(), rhs: __v_15.as_canonical_u64(), msg: Some("ctor parameter type disagrees with the inductive's".to_string()) });
                 }
+                let __v_16: G = G::from_u64(1);
+                let __v_17: G = (__v_2 - __v_16);
+                let __r_arr: [G; OUT_540] = { let __args: [G; IN_540] = [__v_6, __v_10, __v_17, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[540].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_540] = unsafe { *(result.output.as_ptr() as *const [G; OUT_540]) }; __ret } else { aiur_fn_540(__args, record, io_buffer, __cu)? } };
+                let __ret: [G; OUT_540] = [];
+                record.function_queries[540].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[657].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_657] = unsafe { *(result.output.as_ptr() as *const [G; OUT_657]) }; __ret } else { aiur_fn_657(__args, record, io_buffer, __cu)? } };
-                let __v_46: G = __r_arr[0];
-                let __v_47: G = __r_arr[1];
-                let __ret: [G; OUT_625] = [__v_46, __v_47];
-                record.function_queries[625].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
+                return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64()));
               },
             }
           },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_19.as_canonical_u64()));
+            return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_16.as_canonical_u64()));
-      },
     }
   })
 }
 
-const INPUT_SIZE_626: usize = 11;
-const IN_626: usize = 11;
-const OUT_626: usize = 1;
-fn aiur_fn_626(
-  inp: [G; IN_626],
+const INPUT_SIZE_541: usize = 3;
+const IN_541: usize = 3;
+const OUT_541: usize = 0;
+fn aiur_fn_541(
+  inp: [G; IN_541],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_626], ExecError> {
+) -> Result<[G; OUT_541], 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 __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_0, __v_1, __v_2, __v_3, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[647].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_647] = unsafe { *(result.output.as_ptr() as *const [G; OUT_647]) }; __ret } else { aiur_fn_647(__args, record, io_buffer, __cu)? } };
-    let __v_11: G = __r_arr[0];
-    let __v_12: G = G::from_u64(0);
-    let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_11, __v_4, __v_5, __v_6, __v_8, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } else { aiur_fn_627(__args, record, io_buffer, __cu)? } };
-    let __v_13: G = __r_arr[0];
-    let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_13, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[555].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_555] = unsafe { *(result.output.as_ptr() as *const [G; OUT_555]) }; __ret } else { aiur_fn_555(__args, record, io_buffer, __cu)? } };
-    let __v_14: G = __r_arr[0];
-    let __ret: [G; OUT_626] = [__v_14];
-    record.function_queries[626].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __v_3: G = G::from_u64(1);
+    let __v_4: G = G::from_u64(1);
+    let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __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 __r_arr: [G; OUT_540] = { let __args: [G; IN_540] = [__v_0, __v_1, __v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[540].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_540] = unsafe { *(result.output.as_ptr() as *const [G; OUT_540]) }; __ret } else { aiur_fn_540(__args, record, io_buffer, __cu)? } };
+    let __ret: [G; OUT_541] = [];
+    record.function_queries[541].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_627: usize = 6;
-const IN_627: usize = 6;
-const OUT_627: usize = 1;
-fn aiur_fn_627(
-  inp: [G; IN_627],
+const INPUT_SIZE_542: usize = 3;
+const IN_542: usize = 3;
+const OUT_542: usize = 1;
+fn aiur_fn_542(
+  inp: [G; IN_542],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_627], ExecError> {
+) -> Result<[G; OUT_542], 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_628] = { let __args: [G; IN_628] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[628].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_628] = unsafe { *(result.output.as_ptr() as *const [G; OUT_628]) }; __ret } else { aiur_fn_628(__args, record, io_buffer, __cu)? } };
-    let __v_6: G = __r_arr[0];
-    let __v_7: G = __r_arr[1];
-    match __v_6.as_canonical_u64() {
-      1u64 => {
-        let __ret: [G; OUT_627] = [__v_7];
-        record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        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_8: G = __loaded[0];
-        let __v_9: G = __loaded[1];
-        let __v_10: G = __loaded[2];
-        let __v_11: G = __loaded[3];
-        match __v_8.as_canonical_u64() {
-          3u64 => {
-            let __v_12: G = G::from_u64(3);
-            let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } else { aiur_fn_627(__args, record, io_buffer, __cu)? } };
-            let __v_13: G = __r_arr[0];
-            let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_10, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } else { aiur_fn_627(__args, record, io_buffer, __cu)? } };
-            let __v_14: G = __r_arr[0];
-            let __v_15: G = G::from_u64(0);
-            let __v_16: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_15]; 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_627] = [__v_16];
-            record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = unsafe { *(result.output.as_ptr() as *const [G; OUT_377]) }; __ret } else { aiur_fn_377(__args, record, io_buffer, __cu)? } };
+    let __v_3: G = __r_arr[0];
+    match __v_1.as_canonical_u64() {
+      0u64 => {
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; 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: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __v_4: G = __loaded[0];
+        let __v_5: G = __loaded[1];
+        let __v_6: G = __loaded[2];
+        let __v_7: G = __loaded[3];
+        match __v_4.as_canonical_u64() {
+          1u64 => {
+            let __ret: [G; OUT_542] = [__v_5];
+            record.function_queries[542].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
-          4u64 => {
-            let __v_12: G = G::from_u64(4);
-            let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } else { aiur_fn_627(__args, record, io_buffer, __cu)? } };
-            let __v_13: G = __r_arr[0];
-            let __v_14: G = G::from_u64(1);
-            let __v_15: G = (__v_5 + __v_14);
-            let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_10, __v_1, __v_2, __v_3, __v_4, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } else { aiur_fn_627(__args, record, io_buffer, __cu)? } };
-            let __v_16: G = __r_arr[0];
-            let __v_17: G = G::from_u64(0);
-            let __v_18: G = { let __values: [G; 4] = [__v_12, __v_13, __v_16, __v_17]; 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_627] = [__v_18];
-            record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
           },
+        }
+      },
+      _ => {
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; 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: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __v_4: G = __loaded[0];
+        let __v_5: G = __loaded[1];
+        let __v_6: G = __loaded[2];
+        let __v_7: G = __loaded[3];
+        match __v_4.as_canonical_u64() {
           5u64 => {
-            let __v_12: G = G::from_u64(5);
-            let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } else { aiur_fn_627(__args, record, io_buffer, __cu)? } };
-            let __v_13: G = __r_arr[0];
-            let __v_14: G = G::from_u64(1);
-            let __v_15: G = (__v_5 + __v_14);
-            let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_10, __v_1, __v_2, __v_3, __v_4, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } else { aiur_fn_627(__args, record, io_buffer, __cu)? } };
-            let __v_16: G = __r_arr[0];
-            let __v_17: G = G::from_u64(0);
-            let __v_18: G = { let __values: [G; 4] = [__v_12, __v_13, __v_16, __v_17]; 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_627] = [__v_18];
-            record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          6u64 => {
-            let __v_12: G = G::from_u64(6);
-            let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } else { aiur_fn_627(__args, record, io_buffer, __cu)? } };
-            let __v_13: G = __r_arr[0];
-            let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_10, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } else { aiur_fn_627(__args, record, io_buffer, __cu)? } };
-            let __v_14: G = __r_arr[0];
-            let __v_15: G = G::from_u64(1);
-            let __v_16: G = (__v_5 + __v_15);
-            let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_11, __v_1, __v_2, __v_3, __v_4, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } else { aiur_fn_627(__args, record, io_buffer, __cu)? } };
-            let __v_17: G = __r_arr[0];
-            let __v_18: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_17]; 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_627] = [__v_18];
-            record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          8u64 => {
-            let __v_12: G = G::from_u64(8);
-            let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_11, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } else { aiur_fn_627(__args, record, io_buffer, __cu)? } };
-            let __v_13: G = __r_arr[0];
-            let __v_14: G = { let __values: [G; 4] = [__v_12, __v_9, __v_10, __v_13]; 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_627] = [__v_14];
-            record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __v_8: G = G::from_u64(1);
+            let __v_9: G = (__v_1 - __v_8);
+            let __v_10: G = G::from_u64(0);
+            let __v_11: G = { let __values: [G; 3] = [__v_10, __v_5, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_542] = { let __args: [G; IN_542] = [__v_6, __v_9, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } else { aiur_fn_542(__args, record, io_buffer, __cu)? } };
+            let __v_12: G = __r_arr[0];
+            let __ret: [G; OUT_542] = [__v_12];
+            record.function_queries[542].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __ret: [G; OUT_627] = [__v_0];
-            record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
+            return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
           },
         }
       },
@@ -53212,374 +45231,430 @@ fn aiur_fn_627(
   })
 }
 
-const INPUT_SIZE_628: usize = 6;
-const IN_628: usize = 6;
-const OUT_628: usize = 2;
-fn aiur_fn_628(
-  inp: [G; IN_628],
+const INPUT_SIZE_543: usize = 3;
+const IN_543: usize = 3;
+const OUT_543: usize = 0;
+fn aiur_fn_543(
+  inp: [G; IN_543],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_628], ExecError> {
+) -> Result<[G; OUT_543], 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_189] = { let __args: [G; IN_189] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[189].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_189] = unsafe { *(result.output.as_ptr() as *const [G; OUT_189]) }; __ret } else { aiur_fn_189(__args, record, io_buffer, __cu)? } };
-    let __v_6: G = __r_arr[0];
-    let __v_7: G = __r_arr[1];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; 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: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].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];
-    match __v_8.as_canonical_u64() {
-      2u64 => {
-        let __v_12: G = G::from_u64(0);
-        let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_0, __v_9, __v_7, __v_1, __v_2, __v_3, __v_4, __v_5, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[629].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_629] = unsafe { *(result.output.as_ptr() as *const [G; OUT_629]) }; __ret } else { aiur_fn_629(__args, record, io_buffer, __cu)? } };
-        let __v_13: G = __r_arr[0];
-        let __v_14: G = __r_arr[1];
-        let __ret: [G; OUT_628] = [__v_13, __v_14];
-        record.function_queries[628].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_3: G = __loaded[0];
+    let __v_4: G = __loaded[1];
+    let __v_5: G = __loaded[2];
+    let __v_6: G = __loaded[3];
+    match __v_3.as_canonical_u64() {
+      5u64 => {
+        let __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[444].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_444] = unsafe { *(result.output.as_ptr() as *const [G; OUT_444]) }; __ret } else { aiur_fn_444(__args, record, io_buffer, __cu)? } };
+        let __v_7: G = __r_arr[0];
+        let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } else { aiur_fn_294(__args, record, io_buffer, __cu)? } };
+        let __v_8: G = __r_arr[0];
+        let __v_9: G = G::from_u64(1);
+        if (__v_8 != __v_9) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_8.as_canonical_u64(), rhs: __v_9.as_canonical_u64(), msg: Some("ctor field lives in a universe above the inductive's".to_string()) });
+        }
+        let __v_10: G = G::from_u64(0);
+        let __v_11: G = { let __values: [G; 3] = [__v_10, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_543] = { let __args: [G; IN_543] = [__v_5, __v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[543].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_543] = unsafe { *(result.output.as_ptr() as *const [G; OUT_543]) }; __ret } else { aiur_fn_543(__args, record, io_buffer, __cu)? } };
+        let __ret: [G; OUT_543] = [];
+        record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __v_12: G = G::from_u64(0);
-        let __ret: [G; OUT_628] = [__v_12, __v_0];
-        record.function_queries[628].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_543] = [];
+        record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_629: usize = 9;
-const IN_629: usize = 9;
-const OUT_629: usize = 2;
-fn aiur_fn_629(
-  inp: [G; IN_629],
+const INPUT_SIZE_544: usize = 4;
+const IN_544: usize = 4;
+const OUT_544: usize = 0;
+fn aiur_fn_544(
+  inp: [G; IN_544],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_629], ExecError> {
+) -> Result<[G; OUT_544], 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; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; 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: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].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];
-    match __v_9.as_canonical_u64() {
-      1u64 => {
-        let __v_15: G = G::from_u64(0);
-        let __ret: [G; OUT_629] = [__v_15, __v_0];
-        record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    match __v_1.as_canonical_u64() {
+      0u64 => {
+        let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[543].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_543] = unsafe { *(result.output.as_ptr() as *const [G; OUT_543]) }; __ret } else { aiur_fn_543(__args, record, io_buffer, __cu)? } };
+        let __ret: [G; OUT_544] = [];
+        record.function_queries[544].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __v_15: G = (__v_10 - __v_1);
-        match __v_15.as_canonical_u64() {
-          0u64 => {
-            let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { 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_16: G = __r_arr[0];
-            let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { 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_17: G = __r_arr[0];
-            let __v_18: G = { let __a_val = __v_17.as_canonical_u64(); let __b_val = __v_16.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_18.as_canonical_u64() {
-              1u64 => {
-                let __v_19: G = G::from_u64(1);
-                let __v_20: G = (__v_8 + __v_19);
-                let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_0, __v_1, __v_2, __v_14, __v_4, __v_5, __v_6, __v_7, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[629].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_629] = unsafe { *(result.output.as_ptr() as *const [G; OUT_629]) }; __ret } else { aiur_fn_629(__args, record, io_buffer, __cu)? } };
-                let __v_21: G = __r_arr[0];
-                let __v_22: G = __r_arr[1];
-                let __ret: [G; OUT_629] = [__v_21, __v_22];
-                record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              0u64 => {
-                let __r_arr: [G; OUT_630] = { let __args: [G; IN_630] = [__v_2, __v_12, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[630].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_630] = unsafe { *(result.output.as_ptr() as *const [G; OUT_630]) }; __ret } else { aiur_fn_630(__args, record, io_buffer, __cu)? } };
-                let __v_19: G = __r_arr[0];
-                match __v_19.as_canonical_u64() {
-                  0u64 => {
-                    let __v_20: G = G::from_u64(1);
-                    let __v_21: G = (__v_8 + __v_20);
-                    let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_0, __v_1, __v_2, __v_14, __v_4, __v_5, __v_6, __v_7, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[629].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_629] = unsafe { *(result.output.as_ptr() as *const [G; OUT_629]) }; __ret } else { aiur_fn_629(__args, record, io_buffer, __cu)? } };
-                    let __v_22: G = __r_arr[0];
-                    let __v_23: G = __r_arr[1];
-                    let __ret: [G; OUT_629] = [__v_22, __v_23];
-                    record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
-                  1u64 => {
-                    let __v_20: G = G::from_u64(2);
-                    let __v_21: G = (__v_6 + __v_8);
-                    let __v_22: G = G::from_u64(0);
-                    let __v_23: G = { let __values: [G; 4] = [__v_20, __v_21, __v_4, __v_22]; 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_24: G = G::from_u64(0);
-                    let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_23, __v_5, __v_7, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[631].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_631] = unsafe { *(result.output.as_ptr() as *const [G; OUT_631]) }; __ret } else { aiur_fn_631(__args, record, io_buffer, __cu)? } };
-                    let __v_25: G = __r_arr[0];
-                    let __v_26: G = G::from_u64(1);
-                    let __r_arr: [G; OUT_796] = { let __args: [G; IN_796] = [__v_2, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[796].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_796] = unsafe { *(result.output.as_ptr() as *const [G; OUT_796]) }; __ret } else { aiur_fn_796(__args, record, io_buffer, __cu)? } };
-                    let __v_27: G = __r_arr[0];
-                    let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_25, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[427].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_427] = unsafe { *(result.output.as_ptr() as *const [G; OUT_427]) }; __ret } else { aiur_fn_427(__args, record, io_buffer, __cu)? } };
-                    let __v_28: G = __r_arr[0];
-                    let __ret: [G; OUT_629] = [__v_26, __v_28];
-                    record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
-                  _ => {
-                    return Err(ExecError::MatchNoCase(__v_19.as_canonical_u64()));
-                  },
-                }
-              },
-              _ => {
-                return Err(ExecError::MatchNoCase(__v_18.as_canonical_u64()));
-              },
-            }
+      _ => {
+        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_4: G = __loaded[0];
+        let __v_5: G = __loaded[1];
+        let __v_6: G = __loaded[2];
+        let __v_7: G = __loaded[3];
+        match __v_4.as_canonical_u64() {
+          5u64 => {
+            let __v_8: G = G::from_u64(1);
+            let __v_9: G = (__v_1 - __v_8);
+            let __v_10: G = G::from_u64(0);
+            let __v_11: G = { let __values: [G; 3] = [__v_10, __v_5, __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_544] = { let __args: [G; IN_544] = [__v_6, __v_9, __v_2, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[544].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_544] = unsafe { *(result.output.as_ptr() as *const [G; OUT_544]) }; __ret } else { aiur_fn_544(__args, record, io_buffer, __cu)? } };
+            let __ret: [G; OUT_544] = [];
+            record.function_queries[544].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
           },
           _ => {
-            let __v_16: G = G::from_u64(1);
-            let __v_17: G = (__v_8 + __v_16);
-            let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_0, __v_1, __v_2, __v_14, __v_4, __v_5, __v_6, __v_7, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[629].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_629] = unsafe { *(result.output.as_ptr() as *const [G; OUT_629]) }; __ret } else { aiur_fn_629(__args, record, io_buffer, __cu)? } };
-            let __v_18: G = __r_arr[0];
-            let __v_19: G = __r_arr[1];
-            let __ret: [G; OUT_629] = [__v_18, __v_19];
-            record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
+            return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64()));
-      },
     }
   })
 }
 
-const INPUT_SIZE_630: usize = 3;
-const IN_630: usize = 3;
-const OUT_630: usize = 1;
-fn aiur_fn_630(
-  inp: [G; IN_630],
+const INPUT_SIZE_545: usize = 3;
+const IN_545: usize = 3;
+const OUT_545: usize = 0;
+fn aiur_fn_545(
+  inp: [G; IN_545],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_630], ExecError> {
+) -> Result<[G; OUT_545], 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_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 __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];
     let __v_4: G = __loaded[1];
     let __v_5: G = __loaded[2];
     match __v_3.as_canonical_u64() {
-      1u64 => {
+      0u64 => {
+        let __ret: [G; OUT_545] = [];
+        record.function_queries[545].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
         let __v_6: G = G::from_u64(1);
-        let __ret: [G; OUT_630] = [__v_6];
-        record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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 __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_0, __v_1, __v_2, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[544].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_544] = unsafe { *(result.output.as_ptr() as *const [G; OUT_544]) }; __ret } else { aiur_fn_544(__args, record, io_buffer, __cu)? } };
+        let __ret: [G; OUT_545] = [];
+        record.function_queries[545].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_546: usize = 2;
+const IN_546: usize = 2;
+const OUT_546: usize = 1;
+fn aiur_fn_546(
+  inp: [G; IN_546],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_546], 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_260] = { let __args: [G; IN_260] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[260].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_260] = unsafe { *(result.output.as_ptr() as *const [G; OUT_260]) }; __ret } else { aiur_fn_260(__args, record, io_buffer, __cu)? } };
+    let __v_2: G = __r_arr[0];
+    let __ret: [G; OUT_546] = [__v_2];
+    record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_547: usize = 2;
+const IN_547: usize = 2;
+const OUT_547: usize = 1;
+fn aiur_fn_547(
+  inp: [G; IN_547],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_547], 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_547] = [__v_5];
+        record.function_queries[547].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_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_6: G = __loaded[0];
-        let __v_7: G = __loaded[1];
-        let __v_8: G = __loaded[2];
-        match __v_6.as_canonical_u64() {
+        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_5: G = __r_arr[0];
+        match __v_5.as_canonical_u64() {
           1u64 => {
-            let __v_9: G = G::from_u64(0);
-            let __ret: [G; OUT_630] = [__v_9];
-            record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __v_6: G = G::from_u64(1);
+            let __ret: [G; OUT_547] = [__v_6];
+            record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
-          0u64 => {
-            let __v_9: G = G::from_u64(0);
-            let __r_arr: [G; OUT_413] = { let __args: [G; IN_413] = [__v_4, __v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[413].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_413] = unsafe { *(result.output.as_ptr() as *const [G; OUT_413]) }; __ret } else { aiur_fn_413(__args, record, io_buffer, __cu)? } };
-            let __v_10: G = __r_arr[0];
-            let __r_arr: [G; OUT_668] = { let __args: [G; IN_668] = [__v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[668].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_668] = unsafe { *(result.output.as_ptr() as *const [G; OUT_668]) }; __ret } else { aiur_fn_668(__args, record, io_buffer, __cu)? } };
-            let __v_11: G = __r_arr[0];
-            match __v_11.as_canonical_u64() {
-              1u64 => {
-                let __r_arr: [G; OUT_630] = { let __args: [G; IN_630] = [__v_8, __v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[630].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_630] = unsafe { *(result.output.as_ptr() as *const [G; OUT_630]) }; __ret } else { aiur_fn_630(__args, record, io_buffer, __cu)? } };
-                let __v_12: G = __r_arr[0];
-                let __ret: [G; OUT_630] = [__v_12];
-                record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              _ => {
-                let __v_12: G = G::from_u64(0);
-                let __ret: [G; OUT_630] = [__v_12];
-                record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-            }
-          },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64()));
+            let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[547].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_547] = unsafe { *(result.output.as_ptr() as *const [G; OUT_547]) }; __ret } else { aiur_fn_547(__args, record, io_buffer, __cu)? } };
+            let __v_6: G = __r_arr[0];
+            let __ret: [G; OUT_547] = [__v_6];
+            record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
           },
         }
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_631: usize = 4;
-const IN_631: usize = 4;
-const OUT_631: usize = 1;
-fn aiur_fn_631(
-  inp: [G; IN_631],
+const INPUT_SIZE_548: usize = 2;
+const IN_548: usize = 2;
+const OUT_548: usize = 1;
+fn aiur_fn_548(
+  inp: [G; IN_548],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_631], ExecError> {
+) -> Result<[G; OUT_548], 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_1 - __v_3);
-    match __v_4.as_canonical_u64() {
-      0u64 => {
-        let __ret: [G; OUT_631] = [__v_0];
-        record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[258].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_258] = unsafe { *(result.output.as_ptr() as *const [G; OUT_258]) }; __ret } else { aiur_fn_258(__args, record, io_buffer, __cu)? } };
+    let __v_2: G = __r_arr[0];
+    let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; 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: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+    let __v_3: G = __loaded[0];
+    let __v_4: G = __loaded[1];
+    let __v_5: G = __loaded[2];
+    let __v_6: G = __loaded[3];
+    let __v_7: G = __loaded[4];
+    let __v_8: G = __loaded[5];
+    let __v_9: G = __loaded[6];
+    let __v_10: G = __loaded[7];
+    let __v_11: G = __loaded[8];
+    let __v_12: G = __loaded[9];
+    let __v_13: G = __loaded[10];
+    let __v_14: G = __loaded[11];
+    match __v_3.as_canonical_u64() {
+      5u64 => {
+        let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = [__v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[547].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_547] = unsafe { *(result.output.as_ptr() as *const [G; OUT_547]) }; __ret } else { aiur_fn_547(__args, record, io_buffer, __cu)? } };
+        let __v_15: G = __r_arr[0];
+        let __ret: [G; OUT_548] = [__v_15];
+        record.function_queries[548].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __v_5: G = G::from_u64(0);
-        let __v_6: G = (__v_2 + __v_1);
-        let __v_7: G = G::from_u64(1);
-        let __v_8: G = (__v_7 + __v_3);
-        let __v_9: G = (__v_6 - __v_8);
-        let __v_10: G = G::from_u64(0);
-        let __v_11: G = { let __values: [G; 4] = [__v_5, __v_9, __v_10, __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 __v_12: G = G::from_u64(3);
-        let __v_13: G = G::from_u64(0);
-        let __v_14: G = { let __values: [G; 4] = [__v_12, __v_0, __v_11, __v_13]; 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_15: G = G::from_u64(1);
-        let __v_16: G = (__v_3 + __v_15);
-        let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_14, __v_1, __v_2, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[631].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_631] = unsafe { *(result.output.as_ptr() as *const [G; OUT_631]) }; __ret } else { aiur_fn_631(__args, record, io_buffer, __cu)? } };
-        let __v_17: G = __r_arr[0];
-        let __ret: [G; OUT_631] = [__v_17];
-        record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __v_15: G = G::from_u64(0);
+        let __ret: [G; OUT_548] = [__v_15];
+        record.function_queries[548].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_632: usize = 6;
-const IN_632: usize = 6;
-const OUT_632: usize = 1;
-fn aiur_fn_632(
-  inp: [G; IN_632],
+const INPUT_SIZE_549: usize = 2;
+const IN_549: usize = 2;
+const OUT_549: usize = 1;
+fn aiur_fn_549(
+  inp: [G; IN_549],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_632], ExecError> {
+) -> Result<[G; OUT_549], 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];
-    match __v_4.as_canonical_u64() {
+    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() {
       0u64 => {
         let __v_6: G = G::from_u64(0);
-        let __r_arr: [G; OUT_571] = { let __args: [G; IN_571] = [__v_0, __v_1, __v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[571].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_571] = unsafe { *(result.output.as_ptr() as *const [G; OUT_571]) }; __ret } else { aiur_fn_571(__args, record, io_buffer, __cu)? } };
-        let __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_632] = [__v_7];
-        record.function_queries[632].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_549] = [__v_6];
+        record.function_queries[549].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      _ => {
-        let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_0, __v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[544].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_544] = unsafe { *(result.output.as_ptr() as *const [G; OUT_544]) }; __ret } else { aiur_fn_544(__args, record, io_buffer, __cu)? } };
+      1u64 => {
+        let __v_6: G = G::from_u64(0);
+        let __ret: [G; OUT_549] = [__v_6];
+        record.function_queries[549].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      2u64 => {
+        let __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[548].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_548] = unsafe { *(result.output.as_ptr() as *const [G; OUT_548]) }; __ret } else { aiur_fn_548(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
-        let __ret: [G; OUT_632] = [__v_6];
-        record.function_queries[632].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_549] = [__v_6];
+        record.function_queries[549].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      3u64 => {
+        let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[549].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_549] = unsafe { *(result.output.as_ptr() as *const [G; OUT_549]) }; __ret } else { aiur_fn_549(__args, record, io_buffer, __cu)? } };
+        let __v_6: G = __r_arr[0];
+        match __v_6.as_canonical_u64() {
+          1u64 => {
+            let __v_7: G = G::from_u64(1);
+            let __ret: [G; OUT_549] = [__v_7];
+            record.function_queries[549].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[549].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_549] = unsafe { *(result.output.as_ptr() as *const [G; OUT_549]) }; __ret } else { aiur_fn_549(__args, record, io_buffer, __cu)? } };
+            let __v_7: G = __r_arr[0];
+            let __ret: [G; OUT_549] = [__v_7];
+            record.function_queries[549].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+        }
+      },
+      4u64 => {
+        let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[549].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_549] = unsafe { *(result.output.as_ptr() as *const [G; OUT_549]) }; __ret } else { aiur_fn_549(__args, record, io_buffer, __cu)? } };
+        let __v_6: G = __r_arr[0];
+        match __v_6.as_canonical_u64() {
+          1u64 => {
+            let __v_7: G = G::from_u64(1);
+            let __ret: [G; OUT_549] = [__v_7];
+            record.function_queries[549].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[549].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_549] = unsafe { *(result.output.as_ptr() as *const [G; OUT_549]) }; __ret } else { aiur_fn_549(__args, record, io_buffer, __cu)? } };
+            let __v_7: G = __r_arr[0];
+            let __ret: [G; OUT_549] = [__v_7];
+            record.function_queries[549].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+        }
+      },
+      5u64 => {
+        let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[549].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_549] = unsafe { *(result.output.as_ptr() as *const [G; OUT_549]) }; __ret } else { aiur_fn_549(__args, record, io_buffer, __cu)? } };
+        let __v_6: G = __r_arr[0];
+        match __v_6.as_canonical_u64() {
+          1u64 => {
+            let __v_7: G = G::from_u64(1);
+            let __ret: [G; OUT_549] = [__v_7];
+            record.function_queries[549].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[549].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_549] = unsafe { *(result.output.as_ptr() as *const [G; OUT_549]) }; __ret } else { aiur_fn_549(__args, record, io_buffer, __cu)? } };
+            let __v_7: G = __r_arr[0];
+            let __ret: [G; OUT_549] = [__v_7];
+            record.function_queries[549].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+        }
+      },
+      6u64 => {
+        let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[549].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_549] = unsafe { *(result.output.as_ptr() as *const [G; OUT_549]) }; __ret } else { aiur_fn_549(__args, record, io_buffer, __cu)? } };
+        let __v_6: G = __r_arr[0];
+        match __v_6.as_canonical_u64() {
+          1u64 => {
+            let __v_7: G = G::from_u64(1);
+            let __ret: [G; OUT_549] = [__v_7];
+            record.function_queries[549].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[549].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_549] = unsafe { *(result.output.as_ptr() as *const [G; OUT_549]) }; __ret } else { aiur_fn_549(__args, record, io_buffer, __cu)? } };
+            let __v_7: G = __r_arr[0];
+            match __v_7.as_canonical_u64() {
+              1u64 => {
+                let __v_8: G = G::from_u64(1);
+                let __ret: [G; OUT_549] = [__v_8];
+                record.function_queries[549].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[549].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_549] = unsafe { *(result.output.as_ptr() as *const [G; OUT_549]) }; __ret } else { aiur_fn_549(__args, record, io_buffer, __cu)? } };
+                let __v_8: G = __r_arr[0];
+                let __ret: [G; OUT_549] = [__v_8];
+                record.function_queries[549].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+            }
+          },
+        }
+      },
+      7u64 => {
+        let __v_6: G = G::from_u64(0);
+        let __ret: [G; OUT_549] = [__v_6];
+        record.function_queries[549].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      8u64 => {
+        let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[549].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_549] = unsafe { *(result.output.as_ptr() as *const [G; OUT_549]) }; __ret } else { aiur_fn_549(__args, record, io_buffer, __cu)? } };
+        let __v_6: G = __r_arr[0];
+        let __ret: [G; OUT_549] = [__v_6];
+        record.function_queries[549].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
     }
   })
 }
 
-const INPUT_SIZE_633: usize = 2;
-const IN_633: usize = 2;
-const OUT_633: usize = 1;
-fn aiur_fn_633(
-  inp: [G; IN_633],
+const INPUT_SIZE_550: usize = 2;
+const IN_550: usize = 2;
+const OUT_550: usize = 1;
+fn aiur_fn_550(
+  inp: [G; IN_550],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_633], ExecError> {
+) -> Result<[G; OUT_550], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; 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: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
+    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];
-    let __v_5: G = __loaded[3];
-    let __v_6: G = __loaded[4];
-    let __v_7: G = __loaded[5];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __v_8: G = G::from_u64(1);
-        let __v_9: G = G::from_u64(1);
-        let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __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 __ret: [G; OUT_633] = [__v_10];
-        record.function_queries[633].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __v_5: G = G::from_u64(0);
+        let __ret: [G; OUT_550] = [__v_5];
+        record.function_queries[550].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-        let __v_8: G = __r_arr[0];
-        let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].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 __v_17: G = __loaded[8];
-        let __v_18: G = __loaded[9];
-        let __v_19: G = __loaded[10];
-        match __v_9.as_canonical_u64() {
-          5u64 => {
-            let __v_20: G = G::from_u64(0);
-            let __r_arr: [G; OUT_633] = { let __args: [G; IN_633] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[633].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_633] = unsafe { *(result.output.as_ptr() as *const [G; OUT_633]) }; __ret } else { aiur_fn_633(__args, record, io_buffer, __cu)? } };
-            let __v_21: G = __r_arr[0];
-            let __v_22: G = { let __values: [G; 3] = [__v_20, __v_12, __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 __ret: [G; OUT_633] = [__v_22];
-            record.function_queries[633].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[549].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_549] = unsafe { *(result.output.as_ptr() as *const [G; OUT_549]) }; __ret } else { aiur_fn_549(__args, record, io_buffer, __cu)? } };
+        let __v_5: G = __r_arr[0];
+        match __v_5.as_canonical_u64() {
+          1u64 => {
+            let __v_6: G = G::from_u64(1);
+            let __ret: [G; OUT_550] = [__v_6];
+            record.function_queries[550].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __v_20: G = G::from_u64(0);
-            let __v_21: G = G::from_u64(0);
-            let __r_arr: [G; OUT_633] = { let __args: [G; IN_633] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[633].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_633] = unsafe { *(result.output.as_ptr() as *const [G; OUT_633]) }; __ret } else { aiur_fn_633(__args, record, io_buffer, __cu)? } };
-            let __v_22: G = __r_arr[0];
-            let __v_23: G = { let __values: [G; 3] = [__v_20, __v_21, __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_633] = [__v_23];
-            record.function_queries[633].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[550].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_550] = unsafe { *(result.output.as_ptr() as *const [G; OUT_550]) }; __ret } else { aiur_fn_550(__args, record, io_buffer, __cu)? } };
+            let __v_6: G = __r_arr[0];
+            let __ret: [G; OUT_550] = [__v_6];
+            record.function_queries[550].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -53591,400 +45666,417 @@ fn aiur_fn_633(
   })
 }
 
-const INPUT_SIZE_634: usize = 3;
-const IN_634: usize = 3;
-const OUT_634: usize = 1;
-fn aiur_fn_634(
-  inp: [G; IN_634],
+const INPUT_SIZE_551: usize = 3;
+const IN_551: usize = 3;
+const OUT_551: usize = 2;
+fn aiur_fn_551(
+  inp: [G; IN_551],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_634], ExecError> {
+) -> Result<[G; OUT_551], 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 = G::from_u64(0);
-    let __v_4: G = G::from_u64(0);
-    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 __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 = 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 __v_24: G = G::from_u64(0);
-    let __v_25: G = G::from_u64(0);
-    let __v_26: G = G::from_u64(0);
-    let __v_27: G = G::from_u64(0);
-    let __v_28: G = G::from_u64(0);
-    let __v_29: G = G::from_u64(0);
-    let __v_30: G = G::from_u64(0);
-    let __v_31: G = G::from_u64(0);
-    let __v_32: G = G::from_u64(0);
-    let __v_33: G = G::from_u64(0);
-    let __v_34: G = G::from_u64(0);
-    let __v_35: G = { let __values: [G; 32] = [__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]; 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_122] = { let __args: [G; IN_122] = [__v_1, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_36: G = __r_arr[0];
-    match __v_36.as_canonical_u64() {
-      1u64 => {
-        let __ret: [G; OUT_634] = [__v_0];
-        record.function_queries[634].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    match __v_1.as_canonical_u64() {
+      0u64 => {
+        let __ret: [G; OUT_551] = [__v_0, __v_2];
+        record.function_queries[551].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __v_37: G = G::from_u64(0);
-        let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_1, __v_2, __v_2, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[638].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_638] = unsafe { *(result.output.as_ptr() as *const [G; OUT_638]) }; __ret } else { aiur_fn_638(__args, record, io_buffer, __cu)? } };
-        let __v_38: G = __r_arr[0];
-        let __v_39: G = __r_arr[1];
-        match __v_38.as_canonical_u64() {
-          1u64 => {
-            let __ret: [G; OUT_634] = [__v_39];
-            record.function_queries[634].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_3: G = __loaded[0];
+        let __v_4: G = __loaded[1];
+        let __v_5: G = __loaded[2];
+        let __v_6: G = __loaded[3];
+        match __v_3.as_canonical_u64() {
+          5u64 => {
+            let __v_7: G = G::from_u64(0);
+            let __v_8: G = { let __values: [G; 3] = [__v_7, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_9: G = G::from_u64(1);
+            let __v_10: G = (__v_1 - __v_9);
+            let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_5, __v_10, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[551].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_551] = unsafe { *(result.output.as_ptr() as *const [G; OUT_551]) }; __ret } else { aiur_fn_551(__args, record, io_buffer, __cu)? } };
+            let __v_11: G = __r_arr[0];
+            let __v_12: G = __r_arr[1];
+            let __ret: [G; OUT_551] = [__v_11, __v_12];
+            record.function_queries[551].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __ret: [G; OUT_634] = [__v_0];
-            record.function_queries[634].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_551] = [__v_0, __v_2];
+            record.function_queries[551].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_36.as_canonical_u64()));
-      },
     }
   })
 }
 
-const INPUT_SIZE_635: usize = 3;
-const IN_635: usize = 3;
-const OUT_635: usize = 1;
-fn aiur_fn_635(
-  inp: [G; IN_635],
+const INPUT_SIZE_552: usize = 3;
+const IN_552: usize = 3;
+const OUT_552: usize = 0;
+fn aiur_fn_552(
+  inp: [G; IN_552],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_635], ExecError> {
+) -> Result<[G; OUT_552], 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_640] = { let __args: [G; IN_640] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[640].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_640] = unsafe { *(result.output.as_ptr() as *const [G; OUT_640]) }; __ret } else { aiur_fn_640(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[549].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_549] = unsafe { *(result.output.as_ptr() as *const [G; OUT_549]) }; __ret } else { aiur_fn_549(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
-    let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; 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: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr };
-    let __v_4: G = __loaded[0];
-    let __v_5: G = __loaded[1];
-    let __v_6: G = __loaded[2];
-    let __v_7: G = __loaded[3];
-    let __v_8: G = __loaded[4];
-    match __v_4.as_canonical_u64() {
-      1u64 => {
-        let __v_9: G = G::from_u64(0);
-        let __ret: [G; OUT_635] = [__v_9];
-        record.function_queries[635].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    match __v_3.as_canonical_u64() {
+      0u64 => {
+        let __ret: [G; OUT_552] = [];
+        record.function_queries[552].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __v_9: G = G::from_u64(1);
-        let __ret: [G; OUT_635] = [__v_9];
-        record.function_queries[635].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = unsafe { *(result.output.as_ptr() as *const [G; OUT_377]) }; __ret } else { aiur_fn_377(__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];
+        let __v_6: G = __loaded[1];
+        let __v_7: G = __loaded[2];
+        let __v_8: G = __loaded[3];
+        match __v_5.as_canonical_u64() {
+          5u64 => {
+            let __v_9: G = G::from_u64(0);
+            let __v_10: G = { let __values: [G; 3] = [__v_9, __v_6, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_549] = { let __args: [G; IN_549] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[549].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_549] = unsafe { *(result.output.as_ptr() as *const [G; OUT_549]) }; __ret } else { aiur_fn_549(__args, record, io_buffer, __cu)? } };
+            let __v_11: G = __r_arr[0];
+            let __v_12: G = G::from_u64(0);
+            if (__v_11 != __v_12) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: Some("strict positivity: block occurs left of an arrow".to_string()) });
+            }
+            let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_7, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[552].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_552] = unsafe { *(result.output.as_ptr() as *const [G; OUT_552]) }; __ret } else { aiur_fn_552(__args, record, io_buffer, __cu)? } };
+            let __ret: [G; OUT_552] = [];
+            record.function_queries[552].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[106].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_106] = unsafe { *(result.output.as_ptr() as *const [G; OUT_106]) }; __ret } else { aiur_fn_106(__args, record, io_buffer, __cu)? } };
+            let __v_9: G = __r_arr[0];
+            let __v_10: G = __r_arr[1];
+            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; 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: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].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];
+            match __v_11.as_canonical_u64() {
+              2u64 => {
+                let __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = [__v_12, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[548].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_548] = unsafe { *(result.output.as_ptr() as *const [G; OUT_548]) }; __ret } else { aiur_fn_548(__args, record, io_buffer, __cu)? } };
+                let __v_15: G = __r_arr[0];
+                match __v_15.as_canonical_u64() {
+                  1u64 => {
+                    let __ret: [G; OUT_552] = [];
+                    record.function_queries[552].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
+                  },
+                  _ => {
+                    let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[258].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_258] = unsafe { *(result.output.as_ptr() as *const [G; OUT_258]) }; __ret } else { aiur_fn_258(__args, record, io_buffer, __cu)? } };
+                    let __v_16: G = __r_arr[0];
+                    let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; 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: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].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];
+                    let __v_25: G = __loaded[8];
+                    let __v_26: G = __loaded[9];
+                    let __v_27: G = __loaded[10];
+                    let __v_28: G = __loaded[11];
+                    match __v_17.as_canonical_u64() {
+                      5u64 => {
+                        let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_10, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } };
+                        let __v_29: G = __r_arr[0];
+                        let __v_30: G = G::from_u64(0);
+                        let __v_31: G = { let __values: [G; 3] = [__v_30, __v_24, __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_721] = { let __args: [G; IN_721] = [__v_10, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } else { aiur_fn_721(__args, record, io_buffer, __cu)? } };
+                        let __v_32: G = __r_arr[0];
+                        let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[709].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_709] = unsafe { *(result.output.as_ptr() as *const [G; OUT_709]) }; __ret } else { aiur_fn_709(__args, record, io_buffer, __cu)? } };
+                        let __v_33: G = __r_arr[0];
+                        let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_29, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[550].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_550] = unsafe { *(result.output.as_ptr() as *const [G; OUT_550]) }; __ret } else { aiur_fn_550(__args, record, io_buffer, __cu)? } };
+                        let __v_34: G = __r_arr[0];
+                        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("strict positivity: block occurs in a nested inductive's index args".to_string()) });
+                        }
+                        let __v_36: G = G::from_u64(0);
+                        let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_24, __v_25, __v_22, __v_31, __v_36, __v_20, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[553].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_553] = unsafe { *(result.output.as_ptr() as *const [G; OUT_553]) }; __ret } else { aiur_fn_553(__args, record, io_buffer, __cu)? } };
+                        let __ret: [G; OUT_552] = [];
+                        record.function_queries[552].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        return Ok(__ret);
+                      },
+                      _ => {
+                        return Err(ExecError::MatchNoCase(__v_17.as_canonical_u64()));
+                      },
+                    }
+                  },
+                }
+              },
+              _ => {
+                return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64()));
+              },
+            }
+          },
+        }
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_553: usize = 7;
+const IN_553: usize = 7;
+const OUT_553: usize = 0;
+fn aiur_fn_553(
+  inp: [G; IN_553],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_553], 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 = (__v_2 - __v_4);
+    match __v_7.as_canonical_u64() {
+      0u64 => {
+        let __ret: [G; OUT_553] = [];
+        record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
+      _ => {
+        let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_0, __v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[261].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_261] = unsafe { *(result.output.as_ptr() as *const [G; OUT_261]) }; __ret } else { aiur_fn_261(__args, record, io_buffer, __cu)? } };
+        let __v_8: G = __r_arr[0];
+        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].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 __v_17: G = __loaded[8];
+        let __v_18: G = __loaded[9];
+        let __v_19: G = __loaded[10];
+        let __v_20: G = __loaded[11];
+        match __v_9.as_canonical_u64() {
+          6u64 => {
+            let __v_21: G = G::from_u64(1);
+            let __v_22: G = G::from_u64(1);
+            let __v_23: G = { let __values: [G; 3] = [__v_21, __v_22, __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 __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_11, __v_5, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[551].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_551] = unsafe { *(result.output.as_ptr() as *const [G; OUT_551]) }; __ret } else { aiur_fn_551(__args, record, io_buffer, __cu)? } };
+            let __v_24: G = __r_arr[0];
+            let __v_25: G = __r_arr[1];
+            let __v_26: G = G::from_u64(0);
+            let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_24, __v_6, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } else { aiur_fn_335(__args, record, io_buffer, __cu)? } };
+            let __v_27: G = __r_arr[0];
+            let __v_28: G = G::from_u64(1);
+            let __v_29: G = G::from_u64(1);
+            let __v_30: G = { let __values: [G; 3] = [__v_28, __v_29, __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 __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_27, __v_3, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[554].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_554] = unsafe { *(result.output.as_ptr() as *const [G; OUT_554]) }; __ret } else { aiur_fn_554(__args, record, io_buffer, __cu)? } };
+            let __v_31: G = G::from_u64(1);
+            let __v_32: G = (__v_4 + __v_31);
+            let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_0, __v_1, __v_2, __v_3, __v_32, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[553].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_553] = unsafe { *(result.output.as_ptr() as *const [G; OUT_553]) }; __ret } else { aiur_fn_553(__args, record, io_buffer, __cu)? } };
+            let __ret: [G; OUT_553] = [];
+            record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64()));
+          },
+        }
+      },
     }
   })
 }
 
-const INPUT_SIZE_636: usize = 3;
-const IN_636: usize = 3;
-const OUT_636: usize = 1;
-fn aiur_fn_636(
-  inp: [G; IN_636],
+const INPUT_SIZE_554: usize = 3;
+const IN_554: usize = 3;
+const OUT_554: usize = 0;
+fn aiur_fn_554(
+  inp: [G; IN_554],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_636], ExecError> {
+) -> Result<[G; OUT_554], 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 __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_3: G = __loaded[0];
     let __v_4: G = __loaded[1];
     let __v_5: G = __loaded[2];
+    let __v_6: G = __loaded[3];
     match __v_3.as_canonical_u64() {
-      1u64 => {
-        let __v_6: G = G::from_u64(0);
-        let __ret: [G; OUT_636] = [__v_6];
-        record.function_queries[636].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+      5u64 => {
+        let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[552].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_552] = unsafe { *(result.output.as_ptr() as *const [G; OUT_552]) }; __ret } else { aiur_fn_552(__args, record, io_buffer, __cu)? } };
+        let __v_7: G = G::from_u64(0);
+        let __v_8: G = { let __values: [G; 3] = [__v_7, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_554] = { let __args: [G; IN_554] = [__v_5, __v_1, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[554].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_554] = unsafe { *(result.output.as_ptr() as *const [G; OUT_554]) }; __ret } else { aiur_fn_554(__args, record, io_buffer, __cu)? } };
+        let __ret: [G; OUT_554] = [];
+        record.function_queries[554].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[635].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_635] = unsafe { *(result.output.as_ptr() as *const [G; OUT_635]) }; __ret } else { aiur_fn_635(__args, record, io_buffer, __cu)? } };
-        let __v_6: G = __r_arr[0];
-        match __v_6.as_canonical_u64() {
-          1u64 => {
-            let __v_7: G = G::from_u64(1);
-            let __ret: [G; OUT_636] = [__v_7];
-            record.function_queries[636].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          0u64 => {
-            let __r_arr: [G; OUT_636] = { let __args: [G; IN_636] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[636].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_636] = unsafe { *(result.output.as_ptr() as *const [G; OUT_636]) }; __ret } else { aiur_fn_636(__args, record, io_buffer, __cu)? } };
-            let __v_7: G = __r_arr[0];
-            let __ret: [G; OUT_636] = [__v_7];
-            record.function_queries[636].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()));
+        let __ret: [G; OUT_554] = [];
+        record.function_queries[554].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_637: usize = 2;
-const IN_637: usize = 2;
-const OUT_637: usize = 1;
-fn aiur_fn_637(
-  inp: [G; IN_637],
+const INPUT_SIZE_555: usize = 4;
+const IN_555: usize = 4;
+const OUT_555: usize = 0;
+fn aiur_fn_555(
+  inp: [G; IN_555],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_637], ExecError> {
+) -> Result<[G; OUT_555], 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_559] = { let __args: [G; IN_559] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[559].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_559] = unsafe { *(result.output.as_ptr() as *const [G; OUT_559]) }; __ret } else { aiur_fn_559(__args, record, io_buffer, __cu)? } };
-    let __v_2: G = __r_arr[0];
-    let __r_arr: [G; OUT_636] = { let __args: [G; IN_636] = [__v_2, __v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[636].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_636] = unsafe { *(result.output.as_ptr() as *const [G; OUT_636]) }; __ret } else { aiur_fn_636(__args, record, io_buffer, __cu)? } };
-    let __v_3: G = __r_arr[0];
-    let __ret: [G; OUT_637] = [__v_3];
-    record.function_queries[637].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    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 __v_8: G = { let __values: [G; 3] = [__v_4, __v_2, __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 __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[551].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_551] = unsafe { *(result.output.as_ptr() as *const [G; OUT_551]) }; __ret } else { aiur_fn_551(__args, record, io_buffer, __cu)? } };
+    let __v_9: G = __r_arr[0];
+    let __v_10: G = __r_arr[1];
+    let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_9, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[554].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_554] = unsafe { *(result.output.as_ptr() as *const [G; OUT_554]) }; __ret } else { aiur_fn_554(__args, record, io_buffer, __cu)? } };
+    let __ret: [G; OUT_555] = [];
+    record.function_queries[555].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_638: usize = 4;
-const IN_638: usize = 4;
-const OUT_638: usize = 2;
-fn aiur_fn_638(
-  inp: [G; IN_638],
+const INPUT_SIZE_556: usize = 7;
+const IN_556: usize = 7;
+const OUT_556: usize = 0;
+fn aiur_fn_556(
+  inp: [G; IN_556],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_638], ExecError> {
+) -> Result<[G; OUT_556], 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(0);
-        let __v_8: G = G::from_u64(0);
-        let __ret: [G; OUT_638] = [__v_7, __v_8];
-        record.function_queries[638].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].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];
-        let __v_17: G = __loaded[10];
-        match __v_7.as_canonical_u64() {
-          7u64 => {
-            let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_17, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_18: G = __r_arr[0];
-            match __v_18.as_canonical_u64() {
-              0u64 => {
-                let __v_19: G = G::from_u64(1);
-                let __v_20: G = (__v_3 + __v_19);
-                let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_0, __v_6, __v_2, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[638].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_638] = unsafe { *(result.output.as_ptr() as *const [G; OUT_638]) }; __ret } else { aiur_fn_638(__args, record, io_buffer, __cu)? } };
-                let __v_21: G = __r_arr[0];
-                let __v_22: G = __r_arr[1];
-                let __ret: [G; OUT_638] = [__v_21, __v_22];
-                record.function_queries[638].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              1u64 => {
-                let __r_arr: [G; OUT_587] = { let __args: [G; IN_587] = [__v_14, __v_9, __v_10, __v_12, __v_13, __v_11, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[587].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_587] = unsafe { *(result.output.as_ptr() as *const [G; OUT_587]) }; __ret } else { aiur_fn_587(__args, record, io_buffer, __cu)? } };
-                let __v_19: G = __r_arr[0];
-                let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_2, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-                let __v_20: G = __r_arr[0];
-                let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_20.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr };
-                let __v_21: G = __loaded[0];
-                let __v_22: G = __loaded[1];
-                let __v_23: G = __loaded[2];
-                let __v_24: G = __loaded[3];
-                let __v_25: G = __loaded[4];
-                let __v_26: G = __loaded[5];
-                let __v_27: G = __loaded[6];
-                let __v_28: G = __loaded[7];
-                let __v_29: G = __loaded[8];
-                let __v_30: G = __loaded[9];
-                let __v_31: G = __loaded[10];
-                match __v_21.as_canonical_u64() {
-                  5u64 => {
-                    let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = [__v_19, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[637].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_637] = unsafe { *(result.output.as_ptr() as *const [G; OUT_637]) }; __ret } else { aiur_fn_637(__args, record, io_buffer, __cu)? } };
-                    let __v_32: G = __r_arr[0];
-                    match __v_32.as_canonical_u64() {
-                      0u64 => {
-                        let __v_33: G = G::from_u64(1);
-                        let __v_34: G = (__v_3 + __v_33);
-                        let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_0, __v_6, __v_2, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[638].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_638] = unsafe { *(result.output.as_ptr() as *const [G; OUT_638]) }; __ret } else { aiur_fn_638(__args, record, io_buffer, __cu)? } };
-                        let __v_35: G = __r_arr[0];
-                        let __v_36: G = __r_arr[1];
-                        let __ret: [G; OUT_638] = [__v_35, __v_36];
-                        record.function_queries[638].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                        return Ok(__ret);
-                      },
-                      _ => {
-                        let __v_33: G = G::from_u64(1);
-                        let __ret: [G; OUT_638] = [__v_33, __v_19];
-                        record.function_queries[638].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                        return Ok(__ret);
-                      },
-                    }
-                  },
-                  _ => {
-                    let __v_32: G = G::from_u64(1);
-                    let __v_33: G = (__v_3 + __v_32);
-                    let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_0, __v_6, __v_2, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[638].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_638] = unsafe { *(result.output.as_ptr() as *const [G; OUT_638]) }; __ret } else { aiur_fn_638(__args, record, io_buffer, __cu)? } };
-                    let __v_34: G = __r_arr[0];
-                    let __v_35: G = __r_arr[1];
-                    let __ret: [G; OUT_638] = [__v_34, __v_35];
-                    record.function_queries[638].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
-                }
-              },
-              _ => {
-                return Err(ExecError::MatchNoCase(__v_18.as_canonical_u64()));
-              },
-            }
-          },
-          _ => {
-            let __v_18: G = G::from_u64(1);
-            let __v_19: G = (__v_3 + __v_18);
-            let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_0, __v_6, __v_2, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[638].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_638] = unsafe { *(result.output.as_ptr() as *const [G; OUT_638]) }; __ret } else { aiur_fn_638(__args, record, io_buffer, __cu)? } };
-            let __v_20: G = __r_arr[0];
-            let __v_21: G = __r_arr[1];
-            let __ret: [G; OUT_638] = [__v_20, __v_21];
-            record.function_queries[638].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-        }
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
-      },
-    }
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = (__v_1 + __v_2);
+    let __v_8: G = G::from_u64(1);
+    let __v_9: G = G::from_u64(1);
+    let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __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 __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_0, __v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } else { aiur_fn_542(__args, record, io_buffer, __cu)? } };
+    let __v_11: G = __r_arr[0];
+    let __v_12: G = G::from_u64(0);
+    let __r_arr: [G; OUT_557] = { let __args: [G; IN_557] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[557].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_557] = unsafe { *(result.output.as_ptr() as *const [G; OUT_557]) }; __ret } else { aiur_fn_557(__args, record, io_buffer, __cu)? } };
+    let __ret: [G; OUT_556] = [];
+    record.function_queries[556].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_639: usize = 4;
-const IN_639: usize = 4;
-const OUT_639: usize = 1;
-fn aiur_fn_639(
-  inp: [G; IN_639],
+const INPUT_SIZE_557: usize = 9;
+const IN_557: usize = 9;
+const OUT_557: usize = 0;
+fn aiur_fn_557(
+  inp: [G; IN_557],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_639], ExecError> {
+) -> Result<[G; OUT_557], 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_1.as_canonical_u64() {
+    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 = (__v_3 - __v_8);
+    match __v_9.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_639] = [__v_3];
-        record.function_queries[639].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_557] = [];
+        record.function_queries[557].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_4: G = __loaded[0];
-        let __v_5: G = __loaded[1];
-        let __v_6: G = __loaded[2];
-        match __v_4.as_canonical_u64() {
-          1u64 => {
-            let __ret: [G; OUT_639] = [__v_3];
-            record.function_queries[639].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          0u64 => {
-            let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-            let __v_7: G = __r_arr[0];
-            let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].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];
-            let __v_18: G = __loaded[10];
-            match __v_8.as_canonical_u64() {
-              5u64 => {
-                let __v_19: G = G::from_u64(1);
-                let __v_20: G = (__v_1 - __v_19);
-                let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { 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_21: G = __r_arr[0];
-                let __v_22: G = (__v_3 + __v_21);
-                let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_6, __v_20, __v_2, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[639].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_639] = unsafe { *(result.output.as_ptr() as *const [G; OUT_639]) }; __ret } else { aiur_fn_639(__args, record, io_buffer, __cu)? } };
-                let __v_23: G = __r_arr[0];
-                let __ret: [G; OUT_639] = [__v_23];
-                record.function_queries[639].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              _ => {
-                let __v_19: G = G::from_u64(1);
-                let __v_20: G = (__v_1 - __v_19);
-                let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_6, __v_20, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[639].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_639] = unsafe { *(result.output.as_ptr() as *const [G; OUT_639]) }; __ret } else { aiur_fn_639(__args, record, io_buffer, __cu)? } };
-                let __v_21: G = __r_arr[0];
-                let __ret: [G; OUT_639] = [__v_21];
-                record.function_queries[639].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
+        let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_5, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[261].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_261] = unsafe { *(result.output.as_ptr() as *const [G; OUT_261]) }; __ret } else { aiur_fn_261(__args, record, io_buffer, __cu)? } };
+        let __v_10: G = __r_arr[0];
+        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; 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: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].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];
+        let __v_21: G = __loaded[10];
+        let __v_22: G = __loaded[11];
+        match __v_11.as_canonical_u64() {
+          6u64 => {
+            let __r_arr: [G; OUT_541] = { let __args: [G; IN_541] = [__v_0, __v_13, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[541].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_541] = unsafe { *(result.output.as_ptr() as *const [G; OUT_541]) }; __ret } else { aiur_fn_541(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_13, __v_17, __v_2, __v_18, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[539].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_539] = unsafe { *(result.output.as_ptr() as *const [G; OUT_539]) }; __ret } else { aiur_fn_539(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_13, __v_17, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[545].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_545] = unsafe { *(result.output.as_ptr() as *const [G; OUT_545]) }; __ret } else { aiur_fn_545(__args, record, io_buffer, __cu)? } };
+            let __v_23: G = G::from_u64(1);
+            let __v_24: G = G::from_u64(1);
+            let __v_25: G = { let __values: [G; 3] = [__v_23, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_555] = { let __args: [G; IN_555] = [__v_13, __v_17, __v_5, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[555].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_555] = unsafe { *(result.output.as_ptr() as *const [G; OUT_555]) }; __ret } else { aiur_fn_555(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_14, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_26: G = __r_arr[0];
+            let __v_27: G = G::from_u64(1);
+            if (__v_26 != __v_27) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_26.as_canonical_u64(), rhs: __v_27.as_canonical_u64(), msg: Some("ctor belongs to a different block than its inductive".to_string()) });
             }
+            if (__v_15 != __v_6) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_15.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: Some("ctor points at a different member of the block".to_string()) });
+            }
+            if (__v_16 != __v_8) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("ctor's stored index differs from its position".to_string()) });
+            }
+            if (__v_17 != __v_1) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_17.as_canonical_u64(), rhs: __v_1.as_canonical_u64(), msg: Some("ctor parameter count differs from the inductive's".to_string()) });
+            }
+            let __v_28: G = G::from_u64(1);
+            let __v_29: G = (__v_8 + __v_28);
+            let __r_arr: [G; OUT_557] = { let __args: [G; IN_557] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[557].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_557] = unsafe { *(result.output.as_ptr() as *const [G; OUT_557]) }; __ret } else { aiur_fn_557(__args, record, io_buffer, __cu)? } };
+            let __ret: [G; OUT_557] = [];
+            record.function_queries[557].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
           },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
+            return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64()));
           },
         }
       },
@@ -53992,383 +46084,558 @@ fn aiur_fn_639(
   })
 }
 
-const INPUT_SIZE_640: usize = 3;
-const IN_640: usize = 3;
-const OUT_640: usize = 1;
-fn aiur_fn_640(
-  inp: [G; IN_640],
+const INPUT_SIZE_558: usize = 12;
+const IN_558: usize = 12;
+const OUT_558: usize = 0;
+fn aiur_fn_558(
+  inp: [G; IN_558],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_640], ExecError> {
+) -> Result<[G; OUT_558], 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_778] = { let __args: [G; IN_778] = [__v_2, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-    let __v_3: G = __r_arr[0];
-    let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr };
-    let __v_4: G = __loaded[0];
-    let __v_5: G = __loaded[1];
-    let __v_6: G = __loaded[2];
-    let __v_7: G = __loaded[3];
-    let __v_8: G = __loaded[4];
-    let __v_9: G = __loaded[5];
-    let __v_10: G = __loaded[6];
-    let __v_11: G = __loaded[7];
-    let __v_12: G = __loaded[8];
-    let __v_13: G = __loaded[9];
-    let __v_14: G = __loaded[10];
-    match __v_4.as_canonical_u64() {
+    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];
+    match __v_0.as_canonical_u64() {
       5u64 => {
-        let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_9, __v_7, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[641].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_641] = unsafe { *(result.output.as_ptr() as *const [G; OUT_641]) }; __ret } else { aiur_fn_641(__args, record, io_buffer, __cu)? } };
-        let __v_15: G = __r_arr[0];
-        let __ret: [G; OUT_640] = [__v_15];
-        record.function_queries[640].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_556] = { let __args: [G; IN_556] = [__v_2, __v_3, __v_4, __v_5, __v_1, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[556].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_556] = unsafe { *(result.output.as_ptr() as *const [G; OUT_556]) }; __ret } else { aiur_fn_556(__args, record, io_buffer, __cu)? } };
+        let __ret: [G; OUT_558] = [];
+        record.function_queries[558].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __v_15: G = G::from_u64(1);
-        let __v_16: G = G::from_u64(1);
-        let __v_17: G = { let __values: [G; 5] = [__v_15, __v_16, __v_16, __v_16, __v_16]; 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_640] = [__v_17];
-        record.function_queries[640].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_558] = [];
+        record.function_queries[558].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_641: usize = 4;
-const IN_641: usize = 4;
-const OUT_641: usize = 1;
-fn aiur_fn_641(
-  inp: [G; IN_641],
+const INPUT_SIZE_559: usize = 13;
+const IN_559: usize = 13;
+const OUT_559: usize = 0;
+fn aiur_fn_559(
+  inp: [G; IN_559],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_641], ExecError> {
+) -> Result<[G; OUT_559], 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_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_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; 5] = [__v_7, __v_8, __v_8, __v_8, __v_8]; 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_641] = [__v_9];
-        record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-        let __v_7: G = __r_arr[0];
-        let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].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];
-        let __v_18: G = __loaded[10];
-        match __v_8.as_canonical_u64() {
-          6u64 => {
-            let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_10, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } else { aiur_fn_524(__args, record, io_buffer, __cu)? } };
-            let __v_19: G = __r_arr[0];
-            let __v_20: G = G::from_u64(0);
-            let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_19, __v_2, __v_3, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[642].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_642] = unsafe { *(result.output.as_ptr() as *const [G; OUT_642]) }; __ret } else { aiur_fn_642(__args, record, io_buffer, __cu)? } };
-            let __v_21: G = __r_arr[0];
-            let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[641].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_641] = unsafe { *(result.output.as_ptr() as *const [G; OUT_641]) }; __ret } else { aiur_fn_641(__args, record, io_buffer, __cu)? } };
-            let __v_22: G = __r_arr[0];
-            let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_21, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } else { aiur_fn_775(__args, record, io_buffer, __cu)? } };
-            let __v_23: G = __r_arr[0];
-            let __ret: [G; OUT_641] = [__v_23];
-            record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    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_0.as_canonical_u64() {
+      5u64 => {
+        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_7, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_13: G = __r_arr[0];
+        match __v_13.as_canonical_u64() {
+          1u64 => {
+            let __ret: [G; OUT_559] = [];
+            record.function_queries[559].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[641].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_641] = unsafe { *(result.output.as_ptr() as *const [G; OUT_641]) }; __ret } else { aiur_fn_641(__args, record, io_buffer, __cu)? } };
-            let __v_19: G = __r_arr[0];
-            let __ret: [G; OUT_641] = [__v_19];
-            record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
+            let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } else { aiur_fn_255(__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 __v_17: G = __r_arr[3];
+            let __v_18: G = __r_arr[4];
+            let __v_19: G = __r_arr[5];
+            let __v_20: G = __r_arr[6];
+            let __v_21: G = __r_arr[7];
+            let __v_22: G = __r_arr[8];
+            let __v_23: G = __r_arr[9];
+            let __v_24: G = __r_arr[10];
+            let __v_25: G = __r_arr[11];
+            let __v_26: G = __r_arr[12];
+            let __v_27: G = __r_arr[13];
+            let __v_28: G = __r_arr[14];
+            let __v_29: G = __r_arr[15];
+            let __v_30: G = __r_arr[16];
+            let __v_31: G = __r_arr[17];
+            let __v_32: G = __r_arr[18];
+            let __v_33: G = __r_arr[19];
+            let __v_34: G = __r_arr[20];
+            let __v_35: G = __r_arr[21];
+            let __v_36: G = __r_arr[22];
+            let __v_37: G = __r_arr[23];
+            let __v_38: G = __r_arr[24];
+            let __v_39: G = __r_arr[25];
+            let __v_40: G = __r_arr[26];
+            let __v_41: G = __r_arr[27];
+            let __v_42: G = __r_arr[28];
+            let __v_43: G = __r_arr[29];
+            let __v_44: G = __r_arr[30];
+            let __v_45: G = __r_arr[31];
+            let __v_46: G = __r_arr[32];
+            let __v_47: G = __r_arr[33];
+            let __v_48: G = __r_arr[34];
+            let __v_49: G = __r_arr[35];
+            let __v_50: G = __r_arr[36];
+            let __v_51: G = __r_arr[37];
+            let __v_52: G = __r_arr[38];
+            let __v_53: G = __r_arr[39];
+            let __v_54: G = __r_arr[40];
+            let __v_55: G = __r_arr[41];
+            let __v_56: G = __r_arr[42];
+            let __v_57: G = __r_arr[43];
+            let __v_58: G = __r_arr[44];
+            let __v_59: G = __r_arr[45];
+            let __v_60: G = __r_arr[46];
+            let __v_61: G = __r_arr[47];
+            match __v_14.as_canonical_u64() {
+              _ => {
+                match __v_14.as_canonical_u64() {
+                  8u64 => {
+                    let __v_62: G = G::from_u64(0);
+                    let __r_arr: [G; OUT_560] = { let __args: [G; IN_560] = [__v_15, __v_2, __v_3, __v_4, __v_8, __v_62, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[560].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_560] = unsafe { *(result.output.as_ptr() as *const [G; OUT_560]) }; __ret } else { aiur_fn_560(__args, record, io_buffer, __cu)? } };
+                    let __ret: [G; OUT_559] = [];
+                    record.function_queries[559].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
+                  },
+                  _ => {
+                    let __ret: [G; OUT_559] = [];
+                    record.function_queries[559].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
+                  },
+                }
+              },
+            }
           },
         }
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
+        let __ret: [G; OUT_559] = [];
+        record.function_queries[559].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_642: usize = 4;
-const IN_642: usize = 4;
-const OUT_642: usize = 1;
-fn aiur_fn_642(
-  inp: [G; IN_642],
+const INPUT_SIZE_560: usize = 7;
+const IN_560: usize = 7;
+const OUT_560: usize = 0;
+fn aiur_fn_560(
+  inp: [G; IN_560],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_642], ExecError> {
+) -> Result<[G; OUT_560], 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; 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_4: G = __loaded[0];
-    let __v_5: G = __loaded[1];
-    let __v_6: G = __loaded[2];
-    let __v_7: G = __loaded[3];
-    match __v_4.as_canonical_u64() {
-      5u64 => {
-        let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[643].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_643] = unsafe { *(result.output.as_ptr() as *const [G; OUT_643]) }; __ret } else { aiur_fn_643(__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_3 + __v_9);
-        let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_6, __v_1, __v_2, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[642].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_642] = unsafe { *(result.output.as_ptr() as *const [G; OUT_642]) }; __ret } else { aiur_fn_642(__args, record, io_buffer, __cu)? } };
-        let __v_11: G = __r_arr[0];
-        let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } else { aiur_fn_775(__args, record, io_buffer, __cu)? } };
-        let __v_12: G = __r_arr[0];
-        let __ret: [G; OUT_642] = [__v_12];
-        record.function_queries[642].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; 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: 47 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 47] = __args[..47].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];
+    let __v_17: G = __loaded[10];
+    let __v_18: G = __loaded[11];
+    let __v_19: G = __loaded[12];
+    let __v_20: G = __loaded[13];
+    let __v_21: G = __loaded[14];
+    let __v_22: G = __loaded[15];
+    let __v_23: G = __loaded[16];
+    let __v_24: G = __loaded[17];
+    let __v_25: G = __loaded[18];
+    let __v_26: G = __loaded[19];
+    let __v_27: G = __loaded[20];
+    let __v_28: G = __loaded[21];
+    let __v_29: G = __loaded[22];
+    let __v_30: G = __loaded[23];
+    let __v_31: G = __loaded[24];
+    let __v_32: G = __loaded[25];
+    let __v_33: G = __loaded[26];
+    let __v_34: G = __loaded[27];
+    let __v_35: G = __loaded[28];
+    let __v_36: G = __loaded[29];
+    let __v_37: G = __loaded[30];
+    let __v_38: G = __loaded[31];
+    let __v_39: G = __loaded[32];
+    let __v_40: G = __loaded[33];
+    let __v_41: G = __loaded[34];
+    let __v_42: G = __loaded[35];
+    let __v_43: G = __loaded[36];
+    let __v_44: G = __loaded[37];
+    let __v_45: G = __loaded[38];
+    let __v_46: G = __loaded[39];
+    let __v_47: G = __loaded[40];
+    let __v_48: G = __loaded[41];
+    let __v_49: G = __loaded[42];
+    let __v_50: G = __loaded[43];
+    let __v_51: G = __loaded[44];
+    let __v_52: G = __loaded[45];
+    let __v_53: G = __loaded[46];
+    match __v_7.as_canonical_u64() {
+      1u64 => {
+        let __ret: [G; OUT_560] = [];
+        record.function_queries[560].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
+      0u64 => {
+        match __v_8.as_canonical_u64() {
+          1u64 => {
+            let __v_54: G = (__v_5 - __v_4);
+            let __v_55: G = G::from_bool((__v_54 == G::ZERO));
+            match __v_55.as_canonical_u64() {
+              1u64 => {
+                let __v_56: G = G::from_u64(1);
+                let __v_57: G = (__v_5 + __v_56);
+                let __r_arr: [G; OUT_560] = { let __args: [G; IN_560] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_57, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[560].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_560] = unsafe { *(result.output.as_ptr() as *const [G; OUT_560]) }; __ret } else { aiur_fn_560(__args, record, io_buffer, __cu)? } };
+                let __ret: [G; OUT_560] = [];
+                record.function_queries[560].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_6, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[260].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_260] = unsafe { *(result.output.as_ptr() as *const [G; OUT_260]) }; __ret } else { aiur_fn_260(__args, record, io_buffer, __cu)? } };
+                let __v_56: G = __r_arr[0];
+                let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_56.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+                let __v_57: G = __loaded[0];
+                let __v_58: G = __loaded[1];
+                let __v_59: G = __loaded[2];
+                let __v_60: G = __loaded[3];
+                let __v_61: G = __loaded[4];
+                let __v_62: G = __loaded[5];
+                let __v_63: G = __loaded[6];
+                let __v_64: G = __loaded[7];
+                let __v_65: G = __loaded[8];
+                let __v_66: G = __loaded[9];
+                let __v_67: G = __loaded[10];
+                let __v_68: G = __loaded[11];
+                match __v_57.as_canonical_u64() {
+                  5u64 => {
+                    let __r_arr: [G; OUT_541] = { let __args: [G; IN_541] = [__v_1, __v_59, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[541].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_541] = unsafe { *(result.output.as_ptr() as *const [G; OUT_541]) }; __ret } else { aiur_fn_541(__args, record, io_buffer, __cu)? } };
+                    let __v_69: G = (__v_2 + __v_3);
+                    let __v_70: G = G::from_u64(1);
+                    let __v_71: G = G::from_u64(1);
+                    let __v_72: G = { let __values: [G; 3] = [__v_70, __v_71, __v_71]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_542] = { let __args: [G; IN_542] = [__v_1, __v_69, __v_72]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } else { aiur_fn_542(__args, record, io_buffer, __cu)? } };
+                    let __v_73: G = __r_arr[0];
+                    let __v_74: G = (__v_60 + __v_61);
+                    let __v_75: G = G::from_u64(1);
+                    let __v_76: G = G::from_u64(1);
+                    let __v_77: G = { let __values: [G; 3] = [__v_75, __v_76, __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 __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_59, __v_74, __v_77]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } else { aiur_fn_542(__args, record, io_buffer, __cu)? } };
+                    let __v_78: G = __r_arr[0];
+                    if (__v_60 != __v_2) {
+                      return Err(ExecError::AssertEqMismatch { lhs: __v_60.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("mutual block peers disagree on parameter count".to_string()) });
+                    }
+                    let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_73, __v_78]; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } else { aiur_fn_295(__args, record, io_buffer, __cu)? } };
+                    let __v_79: G = __r_arr[0];
+                    let __v_80: G = G::from_u64(1);
+                    if (__v_79 != __v_80) {
+                      return Err(ExecError::AssertEqMismatch { lhs: __v_79.as_canonical_u64(), rhs: __v_80.as_canonical_u64(), msg: Some("mutual block peers land in different universes".to_string()) });
+                    }
+                    let __v_81: G = G::from_u64(1);
+                    let __v_82: G = (__v_5 + __v_81);
+                    let __r_arr: [G; OUT_560] = { let __args: [G; IN_560] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_82, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[560].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_560] = unsafe { *(result.output.as_ptr() as *const [G; OUT_560]) }; __ret } else { aiur_fn_560(__args, record, io_buffer, __cu)? } };
+                    let __ret: [G; OUT_560] = [];
+                    record.function_queries[560].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
+                  },
+                  _ => {
+                    let __v_69: G = G::from_u64(1);
+                    let __v_70: G = (__v_5 + __v_69);
+                    let __r_arr: [G; OUT_560] = { let __args: [G; IN_560] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_70, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[560].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_560] = unsafe { *(result.output.as_ptr() as *const [G; OUT_560]) }; __ret } else { aiur_fn_560(__args, record, io_buffer, __cu)? } };
+                    let __ret: [G; OUT_560] = [];
+                    record.function_queries[560].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
+                  },
+                }
+              },
+            }
+          },
+          _ => {
+            let __v_54: G = G::from_u64(1);
+            let __v_55: G = (__v_5 + __v_54);
+            let __r_arr: [G; OUT_560] = { let __args: [G; IN_560] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_55, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[560].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_560] = unsafe { *(result.output.as_ptr() as *const [G; OUT_560]) }; __ret } else { aiur_fn_560(__args, record, io_buffer, __cu)? } };
+            let __ret: [G; OUT_560] = [];
+            record.function_queries[560].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+        }
+      },
       _ => {
-        let __v_8: G = G::from_u64(1);
-        let __v_9: G = G::from_u64(1);
-        let __v_10: G = { let __values: [G; 5] = [__v_8, __v_9, __v_9, __v_9, __v_9]; 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_642] = [__v_10];
-        record.function_queries[642].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
+        return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_643: usize = 4;
-const IN_643: usize = 4;
-const OUT_643: usize = 1;
-fn aiur_fn_643(
-  inp: [G; IN_643],
+const INPUT_SIZE_561: usize = 15;
+const IN_561: usize = 15;
+const OUT_561: usize = 1;
+fn aiur_fn_561(
+  inp: [G; IN_561],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_643], ExecError> {
+) -> Result<[G; OUT_561], 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_568] = { let __args: [G; IN_568] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[568].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_568] = unsafe { *(result.output.as_ptr() as *const [G; OUT_568]) }; __ret } else { aiur_fn_568(__args, record, io_buffer, __cu)? } };
-    let __v_4: G = __r_arr[0];
-    let __v_5: G = __r_arr[1];
-    let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[189].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_189] = unsafe { *(result.output.as_ptr() as *const [G; OUT_189]) }; __ret } else { aiur_fn_189(__args, record, io_buffer, __cu)? } };
-    let __v_6: G = __r_arr[0];
-    let __v_7: G = __r_arr[1];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; 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: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].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];
-    match __v_8.as_canonical_u64() {
-      2u64 => {
-        let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } else { aiur_fn_528(__args, record, io_buffer, __cu)? } };
-        let __v_12: G = __r_arr[0];
-        match __v_12.as_canonical_u64() {
-          1u64 => {
-            let __v_13: G = G::from_u64(1);
-            let __v_14: G = G::from_u64(1);
-            let __v_15: G = { let __values: [G; 5] = [__v_13, __v_14, __v_14, __v_14, __v_14]; 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_643] = [__v_15];
-            record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    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 __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } else { aiur_fn_269(__args, record, io_buffer, __cu)? } };
+    let __v_15: G = __r_arr[0];
+    match __v_15.as_canonical_u64() {
+      1u64 => {
+        let __v_16: G = G::from_u64(1);
+        let __ret: [G; OUT_561] = [__v_16];
+        record.function_queries[561].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        match __v_1.as_canonical_u64() {
+          0u64 => {
+            let __v_16: G = G::from_u64(1);
+            let __ret: [G; OUT_561] = [__v_16];
+            record.function_queries[561].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
-          0u64 => {
-            let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-            let __v_13: G = __r_arr[0];
-            let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].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];
-            let __v_18: G = __loaded[4];
-            let __v_19: G = __loaded[5];
-            let __v_20: G = __loaded[6];
-            let __v_21: G = __loaded[7];
-            let __v_22: G = __loaded[8];
-            let __v_23: G = __loaded[9];
-            let __v_24: G = __loaded[10];
-            match __v_14.as_canonical_u64() {
-              5u64 => {
-                let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { 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_25: G = __r_arr[0];
-                let __v_26: G = { let __a_val = __v_25.as_canonical_u64(); let __b_val = __v_17.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_26.as_canonical_u64() {
-                  1u64 => {
-                    let __v_27: G = G::from_u64(1);
-                    let __v_28: G = G::from_u64(1);
-                    let __v_29: G = { let __values: [G; 5] = [__v_27, __v_28, __v_28, __v_28, __v_28]; 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_643] = [__v_29];
-                    record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
-                  0u64 => {
-                    let __r_arr: [G; OUT_792] = { let __args: [G; IN_792] = [__v_7, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[792].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_792] = unsafe { *(result.output.as_ptr() as *const [G; OUT_792]) }; __ret } else { aiur_fn_792(__args, record, io_buffer, __cu)? } };
-                    let __v_27: G = __r_arr[0];
-                    let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_27, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } else { aiur_fn_533(__args, record, io_buffer, __cu)? } };
-                    let __v_28: G = __r_arr[0];
-                    match __v_28.as_canonical_u64() {
-                      0u64 => {
-                        let __v_29: G = G::from_u64(1);
-                        let __v_30: G = G::from_u64(1);
-                        let __v_31: G = { let __values: [G; 5] = [__v_29, __v_30, __v_30, __v_30, __v_30]; 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_643] = [__v_31];
-                        record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                        return Ok(__ret);
-                      },
-                      1u64 => {
-                        let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { 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_29: G = __r_arr[0];
-                        let __v_30: G = (__v_3 + __v_29);
-                        let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_27, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[644].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_644] = unsafe { *(result.output.as_ptr() as *const [G; OUT_644]) }; __ret } else { aiur_fn_644(__args, record, io_buffer, __cu)? } };
-                        let __v_31: G = __r_arr[0];
-                        match __v_31.as_canonical_u64() {
-                          0u64 => {
-                            let __v_32: G = G::from_u64(1);
-                            let __v_33: G = G::from_u64(1);
-                            let __v_34: G = { let __values: [G; 5] = [__v_32, __v_33, __v_33, __v_33, __v_33]; 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_643] = [__v_34];
-                            record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                            return Ok(__ret);
-                          },
-                          1u64 => {
-                            let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_27, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = unsafe { *(result.output.as_ptr() as *const [G; OUT_645]) }; __ret } else { aiur_fn_645(__args, record, io_buffer, __cu)? } };
-                            let __v_32: G = __r_arr[0];
-                            let __v_33: G = G::from_u64(0);
-                            let __v_34: G = G::from_u64(1);
-                            let __v_35: G = G::from_u64(1);
-                            let __v_36: G = { let __values: [G; 5] = [__v_34, __v_35, __v_35, __v_35, __v_35]; 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 __v_37: G = { let __values: [G; 5] = [__v_33, __v_9, __v_32, __v_10, __v_36]; 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_643] = [__v_37];
-                            record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                            return Ok(__ret);
-                          },
-                          _ => {
-                            return Err(ExecError::MatchNoCase(__v_31.as_canonical_u64()));
-                          },
-                        }
+          1u64 => {
+            match __v_2.as_canonical_u64() {
+              0u64 => {
+                let __v_16: G = G::from_u64(0);
+                let __ret: [G; OUT_561] = [__v_16];
+                record.function_queries[561].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                match __v_3.as_canonical_u64() {
+                  6u64 => {
+                    match __v_10.as_canonical_u64() {
+                      0u64 => {
+                        let __v_16: G = G::from_u64(1);
+                        let __ret: [G; OUT_561] = [__v_16];
+                        record.function_queries[561].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        return Ok(__ret);
                       },
                       _ => {
-                        return Err(ExecError::MatchNoCase(__v_28.as_canonical_u64()));
+                        let __v_16: G = G::from_u64(1);
+                        let __v_17: G = G::from_u64(1);
+                        let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __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 __r_arr: [G; OUT_562] = { let __args: [G; IN_562] = [__v_5, __v_9, __v_10, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[562].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_562] = unsafe { *(result.output.as_ptr() as *const [G; OUT_562]) }; __ret } else { aiur_fn_562(__args, record, io_buffer, __cu)? } };
+                        let __v_19: G = __r_arr[0];
+                        let __ret: [G; OUT_561] = [__v_19];
+                        record.function_queries[561].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        return Ok(__ret);
                       },
                     }
                   },
                   _ => {
-                    return Err(ExecError::MatchNoCase(__v_26.as_canonical_u64()));
+                    let __v_16: G = G::from_u64(0);
+                    let __ret: [G; OUT_561] = [__v_16];
+                    record.function_queries[561].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
                   },
                 }
               },
-              _ => {
-                let __v_25: G = G::from_u64(1);
-                let __v_26: G = G::from_u64(1);
-                let __v_27: G = { let __values: [G; 5] = [__v_25, __v_26, __v_26, __v_26, __v_26]; 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_643] = [__v_27];
-                record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
             }
           },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64()));
+            let __v_16: G = G::from_u64(0);
+            let __ret: [G; OUT_561] = [__v_16];
+            record.function_queries[561].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
           },
         }
       },
-      _ => {
-        let __v_12: G = G::from_u64(1);
-        let __v_13: G = G::from_u64(1);
-        let __v_14: G = { let __values: [G; 5] = [__v_12, __v_13, __v_13, __v_13, __v_13]; 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_643] = [__v_14];
-        record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
     }
   })
 }
 
-const INPUT_SIZE_644: usize = 2;
-const IN_644: usize = 2;
-const OUT_644: usize = 1;
-fn aiur_fn_644(
-  inp: [G; IN_644],
+const INPUT_SIZE_562: usize = 4;
+const IN_562: usize = 4;
+const OUT_562: usize = 1;
+fn aiur_fn_562(
+  inp: [G; IN_562],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_644], ExecError> {
+) -> Result<[G; OUT_562], 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_2: G = inp[2];
+    let __v_3: G = inp[3];
+    match __v_1.as_canonical_u64() {
+      0u64 => {
+        let __v_4: G = G::from_u64(0);
         let __v_5: G = G::from_u64(1);
-        let __ret: [G; OUT_644] = [__v_5];
-        record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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 __r_arr: [G; OUT_563] = { let __args: [G; IN_563] = [__v_0, __v_2, __v_4, __v_3, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[563].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_563] = unsafe { *(result.output.as_ptr() as *const [G; OUT_563]) }; __ret } else { aiur_fn_563(__args, record, io_buffer, __cu)? } };
+        let __v_8: G = __r_arr[0];
+        let __ret: [G; OUT_562] = [__v_8];
+        record.function_queries[562].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
+      _ => {
+        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_4: G = __loaded[0];
+        let __v_5: G = __loaded[1];
+        let __v_6: G = __loaded[2];
+        let __v_7: G = __loaded[3];
+        match __v_4.as_canonical_u64() {
+          5u64 => {
+            let __v_8: G = G::from_u64(0);
+            let __v_9: G = { let __values: [G; 3] = [__v_8, __v_5, __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 __v_10: G = G::from_u64(1);
+            let __v_11: G = (__v_1 - __v_10);
+            let __r_arr: [G; OUT_562] = { let __args: [G; IN_562] = [__v_6, __v_11, __v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[562].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_562] = unsafe { *(result.output.as_ptr() as *const [G; OUT_562]) }; __ret } else { aiur_fn_562(__args, record, io_buffer, __cu)? } };
+            let __v_12: G = __r_arr[0];
+            let __ret: [G; OUT_562] = [__v_12];
+            record.function_queries[562].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            let __v_8: G = G::from_u64(0);
+            let __ret: [G; OUT_562] = [__v_8];
+            record.function_queries[562].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+        }
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_563: usize = 5;
+const IN_563: usize = 5;
+const OUT_563: usize = 1;
+fn aiur_fn_563(
+  inp: [G; IN_563],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_563], 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 = (__v_1 - __v_2);
+    match __v_5.as_canonical_u64() {
       0u64 => {
-        let __v_5: G = G::from_u64(0);
-        let __r_arr: [G; OUT_405] = { let __args: [G; IN_405] = [__v_3, __v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[405].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_405] = unsafe { *(result.output.as_ptr() as *const [G; OUT_405]) }; __ret } else { aiur_fn_405(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[106].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_106] = unsafe { *(result.output.as_ptr() as *const [G; OUT_106]) }; __ret } else { aiur_fn_106(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
+        let __v_7: G = __r_arr[1];
+        let __r_arr: [G; OUT_564] = { let __args: [G; IN_564] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[564].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_564] = unsafe { *(result.output.as_ptr() as *const [G; OUT_564]) }; __ret } else { aiur_fn_564(__args, record, io_buffer, __cu)? } };
+        let __v_8: G = __r_arr[0];
+        let __ret: [G; OUT_563] = [__v_8];
+        record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        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_6: G = __loaded[0];
+        let __v_7: G = __loaded[1];
+        let __v_8: G = __loaded[2];
+        let __v_9: G = __loaded[3];
         match __v_6.as_canonical_u64() {
-          1u64 => {
-            let __v_7: G = G::from_u64(0);
-            let __ret: [G; OUT_644] = [__v_7];
-            record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          0u64 => {
-            let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[644].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_644] = unsafe { *(result.output.as_ptr() as *const [G; OUT_644]) }; __ret } else { aiur_fn_644(__args, record, io_buffer, __cu)? } };
-            let __v_7: G = __r_arr[0];
-            let __ret: [G; OUT_644] = [__v_7];
-            record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+          5u64 => {
+            let __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_7, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[444].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_444] = unsafe { *(result.output.as_ptr() as *const [G; OUT_444]) }; __ret } else { aiur_fn_444(__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(0);
+            let __v_13: G = G::from_u64(0);
+            let __v_14: G = { let __values: [G; 3] = [__v_12, __v_13, __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 __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_10, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } else { aiur_fn_295(__args, record, io_buffer, __cu)? } };
+            let __v_15: G = __r_arr[0];
+            let __v_16: G = (__v_11 - __v_15);
+            let __v_17: G = G::from_u64(1);
+            let __v_18: G = (__v_1 - __v_17);
+            let __v_19: G = (__v_18 - __v_2);
+            let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_16.as_canonical_u64() {
+  0u64 => {
+    break '__mc_0 [__v_4];
+  },
+  _ => {
+    let __v_20: G = G::from_u64(0);
+    let __v_21: G = { let __values: [G; 3] = [__v_20, __v_19, __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 } };
+    break '__mc_0 [__v_21];
+  },
+}
+ };
+            let __v_20: G = __mc_out___mc_0[0];
+            let __v_21: G = G::from_u64(0);
+            let __v_22: G = { let __values: [G; 3] = [__v_21, __v_7, __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 __v_23: G = G::from_u64(1);
+            let __v_24: G = (__v_2 + __v_23);
+            let __r_arr: [G; OUT_563] = { let __args: [G; IN_563] = [__v_8, __v_1, __v_24, __v_22, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[563].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_563] = unsafe { *(result.output.as_ptr() as *const [G; OUT_563]) }; __ret } else { aiur_fn_563(__args, record, io_buffer, __cu)? } };
+            let __v_25: G = __r_arr[0];
+            let __ret: [G; OUT_563] = [__v_25];
+            record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64()));
+            let __v_10: G = G::from_u64(0);
+            let __ret: [G; OUT_563] = [__v_10];
+            record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
     }
   })
 }
 
-const INPUT_SIZE_645: usize = 2;
-const IN_645: usize = 2;
-const OUT_645: usize = 1;
-fn aiur_fn_645(
-  inp: [G; IN_645],
+const INPUT_SIZE_564: usize = 2;
+const IN_564: usize = 2;
+const OUT_564: usize = 1;
+fn aiur_fn_564(
+  inp: [G; IN_564],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_645], ExecError> {
+) -> Result<[G; OUT_564], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -54379,23 +46646,28 @@ fn aiur_fn_645(
     match __v_2.as_canonical_u64() {
       1u64 => {
         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_645] = [__v_7];
-        record.function_queries[645].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_564] = [__v_5];
+        record.function_queries[564].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 __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_3, __v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } else { aiur_fn_417(__args, record, io_buffer, __cu)? } };
-        let __v_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = unsafe { *(result.output.as_ptr() as *const [G; OUT_645]) }; __ret } else { aiur_fn_645(__args, record, io_buffer, __cu)? } };
-        let __v_8: G = __r_arr[0];
-        let __v_9: G = { let __values: [G; 3] = [__v_5, __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 __ret: [G; OUT_645] = [__v_9];
-        record.function_queries[645].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
+        let __r_arr: [G; OUT_565] = { let __args: [G; IN_565] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[565].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_565] = unsafe { *(result.output.as_ptr() as *const [G; OUT_565]) }; __ret } else { aiur_fn_565(__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(0);
+            let __ret: [G; OUT_564] = [__v_6];
+            record.function_queries[564].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            let __r_arr: [G; OUT_564] = { let __args: [G; IN_564] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[564].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_564] = unsafe { *(result.output.as_ptr() as *const [G; OUT_564]) }; __ret } else { aiur_fn_564(__args, record, io_buffer, __cu)? } };
+            let __v_6: G = __r_arr[0];
+            let __ret: [G; OUT_564] = [__v_6];
+            record.function_queries[564].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+        }
       },
       _ => {
         return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
@@ -54404,101 +46676,79 @@ fn aiur_fn_645(
   })
 }
 
-const INPUT_SIZE_646: usize = 6;
-const IN_646: usize = 6;
-const OUT_646: usize = 1;
-fn aiur_fn_646(
-  inp: [G; IN_646],
+const INPUT_SIZE_565: usize = 2;
+const IN_565: usize = 2;
+const OUT_565: usize = 1;
+fn aiur_fn_565(
+  inp: [G; IN_565],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_646], ExecError> {
+) -> Result<[G; OUT_565], 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];
-    match __v_1.as_canonical_u64() {
-      0u64 => {
-        let __ret: [G; OUT_646] = [__v_0];
-        record.function_queries[646].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_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_565] = [__v_5];
+        record.function_queries[565].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      _ => {
-        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 __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_0, __v_8, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } };
-        let __v_9: 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_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: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].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];
-        match __v_10.as_canonical_u64() {
-          5u64 => {
-            let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-            let __v_14: G = __r_arr[0];
-            let __v_15: G = G::from_u64(0);
-            let __r_arr: [G; OUT_419] = { let __args: [G; IN_419] = [__v_12, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[419].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_419] = unsafe { *(result.output.as_ptr() as *const [G; OUT_419]) }; __ret } else { aiur_fn_419(__args, record, io_buffer, __cu)? } };
-            let __v_16: G = __r_arr[0];
-            let __v_17: G = G::from_u64(1);
-            let __v_18: G = (__v_1 - __v_17);
-            let __v_19: G = G::from_u64(1);
-            let __v_20: G = (__v_3 + __v_19);
-            let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_16, __v_18, __v_2, __v_20, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } else { aiur_fn_646(__args, record, io_buffer, __cu)? } };
-            let __v_21: G = __r_arr[0];
-            let __ret: [G; OUT_646] = [__v_21];
-            record.function_queries[646].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_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: 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() {
+          0u64 => {
+            let __v_9: G = (__v_6 - __v_1);
+            match __v_9.as_canonical_u64() {
+              0u64 => {
+                let __v_10: G = G::from_u64(1);
+                let __ret: [G; OUT_565] = [__v_10];
+                record.function_queries[565].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                let __r_arr: [G; OUT_565] = { let __args: [G; IN_565] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[565].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_565] = unsafe { *(result.output.as_ptr() as *const [G; OUT_565]) }; __ret } else { aiur_fn_565(__args, record, io_buffer, __cu)? } };
+                let __v_10: G = __r_arr[0];
+                let __ret: [G; OUT_565] = [__v_10];
+                record.function_queries[565].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+            }
           },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64()));
+            let __r_arr: [G; OUT_565] = { let __args: [G; IN_565] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[565].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_565] = unsafe { *(result.output.as_ptr() as *const [G; OUT_565]) }; __ret } else { aiur_fn_565(__args, record, io_buffer, __cu)? } };
+            let __v_9: G = __r_arr[0];
+            let __ret: [G; OUT_565] = [__v_9];
+            record.function_queries[565].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
           },
         }
       },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
     }
   })
 }
 
-const INPUT_SIZE_647: usize = 6;
-const IN_647: usize = 6;
-const OUT_647: usize = 1;
-fn aiur_fn_647(
-  inp: [G; IN_647],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_647], 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_228] = { let __args: [G; IN_228] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } };
-    let __v_6: G = __r_arr[0];
-    let __v_7: G = G::from_u64(0);
-    let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_6, __v_1, __v_2, __v_7, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } else { aiur_fn_646(__args, record, io_buffer, __cu)? } };
-    let __v_8: G = __r_arr[0];
-    let __ret: [G; OUT_647] = [__v_8];
-    record.function_queries[647].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_648: usize = 21;
-const IN_648: usize = 21;
-const OUT_648: usize = 1;
-fn aiur_fn_648(
-  inp: [G; IN_648],
+const INPUT_SIZE_566: usize = 13;
+const IN_566: usize = 13;
+const OUT_566: usize = 1;
+fn aiur_fn_566(
+  inp: [G; IN_566],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_648], ExecError> {
+) -> Result<[G; OUT_566], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -54513,350 +46763,416 @@ fn aiur_fn_648(
     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 __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_21: G = __loaded[0];
-    let __v_22: G = __loaded[1];
-    let __v_23: G = __loaded[2];
-    match __v_21.as_canonical_u64() {
-      1u64 => {
-        let __v_24: G = G::from_u64(1);
-        let __v_25: G = G::from_u64(1);
-        let __v_26: G = { let __values: [G; 5] = [__v_24, __v_25, __v_25, __v_25, __v_25]; 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_648] = [__v_26];
-        record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_18, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-        let __v_24: G = __r_arr[0];
-        let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].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];
-        match __v_25.as_canonical_u64() {
-          6u64 => {
-            let __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_0, __v_28, __v_22, __v_27, __v_20, __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]; let __cu = unconstrained; if let Some(result) = record.function_queries[583].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_583] = unsafe { *(result.output.as_ptr() as *const [G; OUT_583]) }; __ret } else { aiur_fn_583(__args, record, io_buffer, __cu)? } };
-            let __v_36: G = __r_arr[0];
-            let __v_37: G = G::from_u64(0);
-            let __v_38: G = G::from_u64(1);
-            let __v_39: G = (__v_20 + __v_38);
-            let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_0, __v_1, __v_23, __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_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[648].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_648] = unsafe { *(result.output.as_ptr() as *const [G; OUT_648]) }; __ret } else { aiur_fn_648(__args, record, io_buffer, __cu)? } };
-            let __v_40: G = __r_arr[0];
-            let __v_41: G = { let __values: [G; 5] = [__v_37, __v_22, __v_31, __v_36, __v_40]; 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_648] = [__v_41];
-            record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    match __v_0.as_canonical_u64() {
+      5u64 => {
+        let __r_arr: [G; OUT_567] = { let __args: [G; IN_567] = [__v_7, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[567].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_567] = unsafe { *(result.output.as_ptr() as *const [G; OUT_567]) }; __ret } else { aiur_fn_567(__args, record, io_buffer, __cu)? } };
+        let __v_13: G = __r_arr[0];
+        match __v_13.as_canonical_u64() {
+          0u64 => {
+            let __v_14: G = G::from_u64(0);
+            let __ret: [G; OUT_566] = [__v_14];
+            record.function_queries[566].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_25.as_canonical_u64()));
+            let __v_14: G = (__v_3 + __v_4);
+            let __v_15: G = G::from_u64(1);
+            let __v_16: G = G::from_u64(1);
+            let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_542] = { let __args: [G; IN_542] = [__v_2, __v_14, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } else { aiur_fn_542(__args, record, io_buffer, __cu)? } };
+            let __v_18: G = __r_arr[0];
+            let __v_19: G = G::from_u64(0);
+            let __v_20: G = G::from_u64(0);
+            let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __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 __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_18, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } else { aiur_fn_295(__args, record, io_buffer, __cu)? } };
+            let __v_22: G = __r_arr[0];
+            match __v_22.as_canonical_u64() {
+              0u64 => {
+                let __v_23: G = G::from_u64(0);
+                let __ret: [G; OUT_566] = [__v_23];
+                record.function_queries[566].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                match __v_5.as_canonical_u64() {
+                  1u64 => {
+                    let __v_23: G = G::from_u64(0);
+                    let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_7, __v_8, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[261].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_261] = unsafe { *(result.output.as_ptr() as *const [G; OUT_261]) }; __ret } else { aiur_fn_261(__args, record, io_buffer, __cu)? } };
+                    let __v_24: G = __r_arr[0];
+                    let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; 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: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].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];
+                    match __v_25.as_canonical_u64() {
+                      6u64 => {
+                        let __v_37: G = G::from_bool((__v_32 == G::ZERO));
+                        let __ret: [G; OUT_566] = [__v_37];
+                        record.function_queries[566].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        return Ok(__ret);
+                      },
+                      _ => {
+                        let __v_37: G = G::from_u64(0);
+                        let __ret: [G; OUT_566] = [__v_37];
+                        record.function_queries[566].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        return Ok(__ret);
+                      },
+                    }
+                  },
+                  _ => {
+                    let __v_23: G = G::from_u64(0);
+                    let __ret: [G; OUT_566] = [__v_23];
+                    record.function_queries[566].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
+                  },
+                }
+              },
+            }
           },
         }
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_21.as_canonical_u64()));
+        let __v_13: G = G::from_u64(0);
+        let __ret: [G; OUT_566] = [__v_13];
+        record.function_queries[566].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_649: usize = 11;
-const IN_649: usize = 11;
-const OUT_649: usize = 1;
-fn aiur_fn_649(
-  inp: [G; IN_649],
+const INPUT_SIZE_567: usize = 2;
+const IN_567: usize = 2;
+const OUT_567: usize = 1;
+fn aiur_fn_567(
+  inp: [G; IN_567],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_649], ExecError> {
+) -> Result<[G; OUT_567], 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 __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_11: G = __loaded[0];
-    let __v_12: G = __loaded[1];
-    let __v_13: G = __loaded[2];
-    match __v_11.as_canonical_u64() {
+    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_2: G = __r_arr[0];
+    match __v_2.as_canonical_u64() {
       1u64 => {
-        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 __ret: [G; OUT_649] = [__v_16];
-        record.function_queries[649].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __v_3: G = G::from_u64(1);
+        let __ret: [G; OUT_567] = [__v_3];
+        record.function_queries[567].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-        let __v_14: G = __r_arr[0];
-        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_3, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-        let __v_15: G = __r_arr[0];
-        let __v_16: G = (__v_5 + __v_10);
-        let __v_17: G = (__v_6 + __v_16);
-        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_2, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-        let __v_18: G = __r_arr[0];
-        let __v_19: G = (__v_5 - __v_12);
-        let __v_20: G = (__v_19 + __v_10);
-        let __v_21: G = G::from_u64(0);
-        let __r_arr: [G; OUT_413] = { let __args: [G; IN_413] = [__v_18, __v_20, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[413].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_413] = unsafe { *(result.output.as_ptr() as *const [G; OUT_413]) }; __ret } else { aiur_fn_413(__args, record, io_buffer, __cu)? } };
-        let __v_22: G = __r_arr[0];
-        let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_22, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } };
-        let __v_23: G = __r_arr[0];
-        let __r_arr: [G; OUT_568] = { let __args: [G; IN_568] = [__v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[568].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_568] = unsafe { *(result.output.as_ptr() as *const [G; OUT_568]) }; __ret } else { aiur_fn_568(__args, record, io_buffer, __cu)? } };
-        let __v_24: G = __r_arr[0];
-        let __v_25: G = __r_arr[1];
-        let __r_arr: [G; OUT_776] = { let __args: [G; IN_776] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[776].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_776] = unsafe { *(result.output.as_ptr() as *const [G; OUT_776]) }; __ret } else { aiur_fn_776(__args, record, io_buffer, __cu)? } };
-        let __v_26: G = __r_arr[0];
-        let __r_arr: [G; OUT_773] = { let __args: [G; IN_773] = [__v_26, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[773].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_773] = unsafe { *(result.output.as_ptr() as *const [G; OUT_773]) }; __ret } else { aiur_fn_773(__args, record, io_buffer, __cu)? } };
-        let __v_27: G = __r_arr[0];
-        let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_25, __v_27, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } };
-        let __v_28: G = __r_arr[0];
-        let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { 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_29: G = __r_arr[0];
-        let __v_30: G = (__v_17 + __v_29);
-        let __v_31: G = G::from_u64(1);
-        let __v_32: G = (__v_30 - __v_31);
-        let __v_33: G = (__v_4 + __v_14);
-        let __v_34: G = (__v_32 - __v_33);
-        let __v_35: G = G::from_u64(1);
-        let __v_36: G = (__v_30 - __v_35);
-        let __v_37: G = (__v_6 + __v_12);
-        let __v_38: G = (__v_36 - __v_37);
-        let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[189].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_189] = unsafe { *(result.output.as_ptr() as *const [G; OUT_189]) }; __ret } else { aiur_fn_189(__args, record, io_buffer, __cu)? } };
-        let __v_39: G = __r_arr[0];
-        let __v_40: G = __r_arr[1];
-        let __r_arr: [G; OUT_796] = { let __args: [G; IN_796] = [__v_40, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[796].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_796] = unsafe { *(result.output.as_ptr() as *const [G; OUT_796]) }; __ret } else { aiur_fn_796(__args, record, io_buffer, __cu)? } };
-        let __v_41: G = __r_arr[0];
-        let __v_42: G = G::from_u64(0);
-        let __v_43: G = G::from_u64(0);
-        let __v_44: G = { let __values: [G; 4] = [__v_42, __v_34, __v_43, __v_43]; 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_427] = { let __args: [G; IN_427] = [__v_44, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[427].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_427] = unsafe { *(result.output.as_ptr() as *const [G; OUT_427]) }; __ret } else { aiur_fn_427(__args, record, io_buffer, __cu)? } };
-        let __v_45: G = __r_arr[0];
-        let __v_46: G = G::from_u64(0);
-        let __v_47: G = G::from_u64(0);
-        let __v_48: G = { let __values: [G; 4] = [__v_46, __v_38, __v_47, __v_47]; 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_49: G = G::from_u64(0);
-        let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_48, __v_29, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[554].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_554] = unsafe { *(result.output.as_ptr() as *const [G; OUT_554]) }; __ret } else { aiur_fn_554(__args, record, io_buffer, __cu)? } };
-        let __v_50: G = __r_arr[0];
-        let __v_51: G = G::from_u64(3);
-        let __v_52: G = G::from_u64(0);
-        let __v_53: G = { let __values: [G; 4] = [__v_51, __v_45, __v_50, __v_52]; 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_555] = { let __args: [G; IN_555] = [__v_53, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[555].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_555] = unsafe { *(result.output.as_ptr() as *const [G; OUT_555]) }; __ret } else { aiur_fn_555(__args, record, io_buffer, __cu)? } };
-        let __v_54: G = __r_arr[0];
-        let __v_55: G = G::from_u64(0);
-        let __v_56: G = G::from_u64(1);
-        let __v_57: G = (__v_10 + __v_56);
-        let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_13, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_57]; let __cu = unconstrained; if let Some(result) = record.function_queries[649].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_649] = unsafe { *(result.output.as_ptr() as *const [G; OUT_649]) }; __ret } else { aiur_fn_649(__args, record, io_buffer, __cu)? } };
-        let __v_58: G = __r_arr[0];
-        let __v_59: G = { let __values: [G; 3] = [__v_55, __v_54, __v_58]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_649] = [__v_59];
-        record.function_queries[649].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
+      _ => {
+        let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } else { aiur_fn_255(__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 __v_13: G = __r_arr[10];
+        let __v_14: G = __r_arr[11];
+        let __v_15: G = __r_arr[12];
+        let __v_16: G = __r_arr[13];
+        let __v_17: G = __r_arr[14];
+        let __v_18: G = __r_arr[15];
+        let __v_19: G = __r_arr[16];
+        let __v_20: G = __r_arr[17];
+        let __v_21: G = __r_arr[18];
+        let __v_22: G = __r_arr[19];
+        let __v_23: G = __r_arr[20];
+        let __v_24: G = __r_arr[21];
+        let __v_25: G = __r_arr[22];
+        let __v_26: G = __r_arr[23];
+        let __v_27: G = __r_arr[24];
+        let __v_28: G = __r_arr[25];
+        let __v_29: G = __r_arr[26];
+        let __v_30: G = __r_arr[27];
+        let __v_31: G = __r_arr[28];
+        let __v_32: G = __r_arr[29];
+        let __v_33: G = __r_arr[30];
+        let __v_34: G = __r_arr[31];
+        let __v_35: G = __r_arr[32];
+        let __v_36: G = __r_arr[33];
+        let __v_37: G = __r_arr[34];
+        let __v_38: G = __r_arr[35];
+        let __v_39: G = __r_arr[36];
+        let __v_40: G = __r_arr[37];
+        let __v_41: G = __r_arr[38];
+        let __v_42: G = __r_arr[39];
+        let __v_43: G = __r_arr[40];
+        let __v_44: G = __r_arr[41];
+        let __v_45: G = __r_arr[42];
+        let __v_46: G = __r_arr[43];
+        let __v_47: G = __r_arr[44];
+        let __v_48: G = __r_arr[45];
+        let __v_49: G = __r_arr[46];
+        let __v_50: G = __r_arr[47];
+        match __v_3.as_canonical_u64() {
+          _ => {
+            match __v_3.as_canonical_u64() {
+              8u64 => {
+                let __v_51: G = G::from_u64(0);
+                let __r_arr: [G; OUT_569] = { let __args: [G; IN_569] = [__v_4, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[569].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_569] = unsafe { *(result.output.as_ptr() as *const [G; OUT_569]) }; __ret } else { aiur_fn_569(__args, record, io_buffer, __cu)? } };
+                let __v_52: G = __r_arr[0];
+                let __ret: [G; OUT_567] = [__v_52];
+                record.function_queries[567].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                let __v_51: G = G::from_u64(0);
+                let __ret: [G; OUT_567] = [__v_51];
+                record.function_queries[567].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+            }
+          },
+        }
       },
+    }
+  })
+}
+
+const INPUT_SIZE_568: usize = 1;
+const IN_568: usize = 1;
+const OUT_568: usize = 1;
+fn aiur_fn_568(
+  inp: [G; IN_568],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_568], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } else { aiur_fn_255(__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 __v_11: G = __r_arr[10];
+    let __v_12: G = __r_arr[11];
+    let __v_13: G = __r_arr[12];
+    let __v_14: G = __r_arr[13];
+    let __v_15: G = __r_arr[14];
+    let __v_16: G = __r_arr[15];
+    let __v_17: G = __r_arr[16];
+    let __v_18: G = __r_arr[17];
+    let __v_19: G = __r_arr[18];
+    let __v_20: G = __r_arr[19];
+    let __v_21: G = __r_arr[20];
+    let __v_22: G = __r_arr[21];
+    let __v_23: G = __r_arr[22];
+    let __v_24: G = __r_arr[23];
+    let __v_25: G = __r_arr[24];
+    let __v_26: G = __r_arr[25];
+    let __v_27: G = __r_arr[26];
+    let __v_28: G = __r_arr[27];
+    let __v_29: G = __r_arr[28];
+    let __v_30: G = __r_arr[29];
+    let __v_31: G = __r_arr[30];
+    let __v_32: G = __r_arr[31];
+    let __v_33: G = __r_arr[32];
+    let __v_34: G = __r_arr[33];
+    let __v_35: G = __r_arr[34];
+    let __v_36: G = __r_arr[35];
+    let __v_37: G = __r_arr[36];
+    let __v_38: G = __r_arr[37];
+    let __v_39: G = __r_arr[38];
+    let __v_40: G = __r_arr[39];
+    let __v_41: G = __r_arr[40];
+    let __v_42: G = __r_arr[41];
+    let __v_43: G = __r_arr[42];
+    let __v_44: G = __r_arr[43];
+    let __v_45: G = __r_arr[44];
+    let __v_46: G = __r_arr[45];
+    let __v_47: G = __r_arr[46];
+    let __v_48: G = __r_arr[47];
+    match __v_1.as_canonical_u64() {
       _ => {
-        return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64()));
+        match __v_1.as_canonical_u64() {
+          8u64 => {
+            let __v_49: G = G::from_u64(1);
+            let __ret: [G; OUT_568] = [__v_49];
+            record.function_queries[568].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            let __v_49: G = G::from_u64(0);
+            let __ret: [G; OUT_568] = [__v_49];
+            record.function_queries[568].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+        }
       },
     }
   })
 }
 
-const INPUT_SIZE_650: usize = 7;
-const IN_650: usize = 7;
-const OUT_650: usize = 0;
-fn aiur_fn_650(
-  inp: [G; IN_650],
+const INPUT_SIZE_569: usize = 2;
+const IN_569: usize = 2;
+const OUT_569: usize = 1;
+fn aiur_fn_569(
+  inp: [G; IN_569],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_650], ExecError> {
+) -> Result<[G; OUT_569], 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 = 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 __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 = 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 __v_24: G = G::from_u64(0);
-    let __v_25: G = G::from_u64(0);
-    let __v_26: G = G::from_u64(0);
-    let __v_27: G = G::from_u64(0);
-    let __v_28: G = G::from_u64(0);
-    let __v_29: G = G::from_u64(0);
-    let __v_30: G = G::from_u64(0);
-    let __v_31: G = G::from_u64(0);
-    let __v_32: G = G::from_u64(0);
-    let __v_33: G = G::from_u64(0);
-    let __v_34: G = G::from_u64(0);
-    let __v_35: G = G::from_u64(0);
-    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 = { let __values: [G; 32] = [__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, __v_37, __v_38]; 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_122] = { let __args: [G; IN_122] = [__v_4, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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];
-    match __v_40.as_canonical_u64() {
+    let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; 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: 47 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 47] = __args[..47].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];
+    let __v_12: G = __loaded[10];
+    let __v_13: G = __loaded[11];
+    let __v_14: G = __loaded[12];
+    let __v_15: G = __loaded[13];
+    let __v_16: G = __loaded[14];
+    let __v_17: G = __loaded[15];
+    let __v_18: G = __loaded[16];
+    let __v_19: G = __loaded[17];
+    let __v_20: G = __loaded[18];
+    let __v_21: G = __loaded[19];
+    let __v_22: G = __loaded[20];
+    let __v_23: G = __loaded[21];
+    let __v_24: G = __loaded[22];
+    let __v_25: G = __loaded[23];
+    let __v_26: G = __loaded[24];
+    let __v_27: G = __loaded[25];
+    let __v_28: G = __loaded[26];
+    let __v_29: G = __loaded[27];
+    let __v_30: G = __loaded[28];
+    let __v_31: G = __loaded[29];
+    let __v_32: G = __loaded[30];
+    let __v_33: G = __loaded[31];
+    let __v_34: G = __loaded[32];
+    let __v_35: G = __loaded[33];
+    let __v_36: G = __loaded[34];
+    let __v_37: G = __loaded[35];
+    let __v_38: G = __loaded[36];
+    let __v_39: G = __loaded[37];
+    let __v_40: G = __loaded[38];
+    let __v_41: G = __loaded[39];
+    let __v_42: G = __loaded[40];
+    let __v_43: G = __loaded[41];
+    let __v_44: G = __loaded[42];
+    let __v_45: G = __loaded[43];
+    let __v_46: G = __loaded[44];
+    let __v_47: G = __loaded[45];
+    let __v_48: G = __loaded[46];
+    match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_650] = [];
-        record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
+        match __v_1.as_canonical_u64() {
+          1u64 => {
+            let __v_49: G = G::from_u64(1);
+            let __ret: [G; OUT_569] = [__v_49];
+            record.function_queries[569].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            let __v_49: G = G::from_u64(0);
+            let __ret: [G; OUT_569] = [__v_49];
+            record.function_queries[569].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+        }
       },
       0u64 => {
-        let __v_41: G = G::from_u64(0);
-        let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_5, __v_6, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[651].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_651] = unsafe { *(result.output.as_ptr() as *const [G; OUT_651]) }; __ret } else { aiur_fn_651(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_650] = [];
-        record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
+        match __v_3.as_canonical_u64() {
+          1u64 => {
+            let __v_49: G = G::from_u64(1);
+            let __v_50: G = (__v_1 + __v_49);
+            let __r_arr: [G; OUT_569] = { let __args: [G; IN_569] = [__v_48, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[569].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_569] = unsafe { *(result.output.as_ptr() as *const [G; OUT_569]) }; __ret } else { aiur_fn_569(__args, record, io_buffer, __cu)? } };
+            let __v_51: G = __r_arr[0];
+            let __ret: [G; OUT_569] = [__v_51];
+            record.function_queries[569].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            let __r_arr: [G; OUT_569] = { let __args: [G; IN_569] = [__v_48, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[569].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_569] = unsafe { *(result.output.as_ptr() as *const [G; OUT_569]) }; __ret } else { aiur_fn_569(__args, record, io_buffer, __cu)? } };
+            let __v_49: G = __r_arr[0];
+            let __ret: [G; OUT_569] = [__v_49];
+            record.function_queries[569].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+        }
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_40.as_canonical_u64()));
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_651: usize = 9;
-const IN_651: usize = 9;
-const OUT_651: usize = 0;
-fn aiur_fn_651(
-  inp: [G; IN_651],
+const INPUT_SIZE_570: usize = 5;
+const IN_570: usize = 5;
+const OUT_570: usize = 1;
+fn aiur_fn_570(
+  inp: [G; IN_570],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_651], ExecError> {
+) -> Result<[G; OUT_570], 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; 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_5: G = (__v_3 + __v_4);
+    let __v_6: G = (__v_2 + __v_5);
+    let __v_7: G = (__v_1 + __v_6);
+    let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } else { aiur_fn_535(__args, record, io_buffer, __cu)? } };
+    let __v_8: 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_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).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_9: G = __loaded[0];
     let __v_10: G = __loaded[1];
     let __v_11: G = __loaded[2];
+    let __v_12: G = __loaded[3];
     match __v_9.as_canonical_u64() {
-      1u64 => {
-        let __ret: [G; OUT_651] = [];
-        record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr };
-        let __v_12: G = __loaded[0];
-        let __v_13: G = __loaded[1];
-        let __v_14: G = __loaded[2];
-        let __v_15: G = __loaded[3];
-        let __v_16: G = __loaded[4];
-        let __v_17: G = __loaded[5];
-        let __v_18: G = __loaded[6];
-        let __v_19: G = __loaded[7];
-        let __v_20: G = __loaded[8];
-        let __v_21: G = __loaded[9];
-        let __v_22: G = __loaded[10];
-        match __v_12.as_canonical_u64() {
-          5u64 => {
-            let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_19, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_23: G = __r_arr[0];
-            let __v_24: G = (__v_8 - __v_0);
-            let __v_25: G = G::from_bool((__v_24 == G::ZERO));
-            let __v_26: G = G::from_u64(1);
-            let __v_27: G = (__v_26 - __v_25);
-            let __v_28: G = (__v_23 * __v_27);
-            match __v_28.as_canonical_u64() {
-              1u64 => {
-                let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_1, __v_14, __v_2, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = unsafe { *(result.output.as_ptr() as *const [G; OUT_652]) }; __ret } else { aiur_fn_652(__args, record, io_buffer, __cu)? } };
-                let __v_29: G = (__v_2 + __v_3);
-                let __v_30: G = G::from_u64(1);
-                let __v_31: G = G::from_u64(1);
-                let __v_32: G = { let __values: [G; 3] = [__v_30, __v_31, __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 __r_arr: [G; OUT_519] = { let __args: [G; IN_519] = [__v_1, __v_29, __v_32, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[519].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_519] = unsafe { *(result.output.as_ptr() as *const [G; OUT_519]) }; __ret } else { aiur_fn_519(__args, record, io_buffer, __cu)? } };
-                let __v_33: G = __r_arr[0];
-                let __v_34: G = (__v_15 + __v_16);
-                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 __r_arr: [G; OUT_519] = { let __args: [G; IN_519] = [__v_14, __v_34, __v_37, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[519].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_519] = unsafe { *(result.output.as_ptr() as *const [G; OUT_519]) }; __ret } else { aiur_fn_519(__args, record, io_buffer, __cu)? } };
-                let __v_38: G = __r_arr[0];
-                if (__v_15 != __v_2) {
-                  return Err(ExecError::AssertEqMismatch { lhs: __v_15.as_canonical_u64(), rhs: __v_2.as_canonical_u64() });
-                }
-                let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_33, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[216].get_mut(&__args[..]) { 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_39: G = __r_arr[0];
-                let __v_40: G = G::from_u64(1);
-                if (__v_39 != __v_40) {
-                  return Err(ExecError::AssertEqMismatch { lhs: __v_39.as_canonical_u64(), rhs: __v_40.as_canonical_u64() });
-                }
-                let __v_41: G = G::from_u64(1);
-                let __v_42: G = (__v_8 + __v_41);
-                let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_11, __v_6, __v_7, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[651].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_651] = unsafe { *(result.output.as_ptr() as *const [G; OUT_651]) }; __ret } else { aiur_fn_651(__args, record, io_buffer, __cu)? } };
-                let __ret: [G; OUT_651] = [];
-                record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              0u64 => {
-                let __v_29: G = G::from_u64(1);
-                let __v_30: G = (__v_8 + __v_29);
-                let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_11, __v_6, __v_7, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[651].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_651] = unsafe { *(result.output.as_ptr() as *const [G; OUT_651]) }; __ret } else { aiur_fn_651(__args, record, io_buffer, __cu)? } };
-                let __ret: [G; OUT_651] = [];
-                record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              _ => {
-                return Err(ExecError::MatchNoCase(__v_28.as_canonical_u64()));
-              },
-            }
+      5u64 => {
+        let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[106].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_106] = unsafe { *(result.output.as_ptr() as *const [G; OUT_106]) }; __ret } else { aiur_fn_106(__args, record, io_buffer, __cu)? } };
+        let __v_13: G = __r_arr[0];
+        let __v_14: G = __r_arr[1];
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; 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: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __v_15: G = __loaded[0];
+        let __v_16: G = __loaded[1];
+        let __v_17: G = __loaded[2];
+        let __v_18: G = __loaded[3];
+        match __v_15.as_canonical_u64() {
+          2u64 => {
+            let __ret: [G; OUT_570] = [__v_16];
+            record.function_queries[570].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
           },
           _ => {
-            let __v_23: G = G::from_u64(1);
-            let __v_24: G = (__v_8 + __v_23);
-            let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_11, __v_6, __v_7, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[651].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_651] = unsafe { *(result.output.as_ptr() as *const [G; OUT_651]) }; __ret } else { aiur_fn_651(__args, record, io_buffer, __cu)? } };
-            let __ret: [G; OUT_651] = [];
-            record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
+            return Err(ExecError::MatchNoCase(__v_15.as_canonical_u64()));
           },
         }
       },
@@ -54867,40 +47183,15 @@ fn aiur_fn_651(
   })
 }
 
-const INPUT_SIZE_652: usize = 5;
-const IN_652: usize = 5;
-const OUT_652: usize = 0;
-fn aiur_fn_652(
-  inp: [G; IN_652],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_652], 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(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 __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_0, __v_1, __v_2, __v_7, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[653].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_653] = unsafe { *(result.output.as_ptr() as *const [G; OUT_653]) }; __ret } else { aiur_fn_653(__args, record, io_buffer, __cu)? } };
-    let __ret: [G; OUT_652] = [];
-    record.function_queries[652].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_653: usize = 6;
-const IN_653: usize = 6;
-const OUT_653: usize = 0;
-fn aiur_fn_653(
-  inp: [G; IN_653],
+const INPUT_SIZE_571: usize = 12;
+const IN_571: usize = 12;
+const OUT_571: usize = 1;
+fn aiur_fn_571(
+  inp: [G; IN_571],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_653], ExecError> {
+) -> Result<[G; OUT_571], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -54908,528 +47199,898 @@ fn aiur_fn_653(
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
-    match __v_2.as_canonical_u64() {
-      0u64 => {
-        let __ret: [G; OUT_653] = [];
-        record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        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_6: G = __loaded[0];
-        let __v_7: G = __loaded[1];
-        let __v_8: G = __loaded[2];
-        let __v_9: G = __loaded[3];
-        match __v_6.as_canonical_u64() {
+    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];
+    match __v_0.as_canonical_u64() {
+      7u64 => {
+        let __v_12: G = (__v_3 + __v_5);
+        let __v_13: G = (__v_12 + __v_6);
+        let __v_14: G = (__v_13 + __v_4);
+        let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_2, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } else { aiur_fn_535(__args, record, io_buffer, __cu)? } };
+        let __v_15: 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_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: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __v_16: G = __loaded[0];
+        let __v_17: G = __loaded[1];
+        let __v_18: G = __loaded[2];
+        let __v_19: G = __loaded[3];
+        match __v_16.as_canonical_u64() {
           5u64 => {
-            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_10: G = __loaded[0];
-            let __v_11: G = __loaded[1];
-            let __v_12: G = __loaded[2];
-            let __v_13: G = __loaded[3];
-            match __v_10.as_canonical_u64() {
-              5u64 => {
-                let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_7, __v_11, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } };
-                let __v_14: G = __r_arr[0];
-                let __v_15: G = G::from_u64(0);
-                let __v_16: G = { let __values: [G; 3] = [__v_15, __v_7, __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 __v_17: G = G::from_u64(1);
-                if (__v_14 != __v_17) {
-                  return Err(ExecError::AssertEqMismatch { lhs: __v_14.as_canonical_u64(), rhs: __v_17.as_canonical_u64() });
-                }
-                let __v_18: G = G::from_u64(1);
-                let __v_19: G = (__v_2 - __v_18);
-                let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_8, __v_12, __v_19, __v_16, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[653].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_653] = unsafe { *(result.output.as_ptr() as *const [G; OUT_653]) }; __ret } else { aiur_fn_653(__args, record, io_buffer, __cu)? } };
-                let __ret: [G; OUT_653] = [];
-                record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[106].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_106] = unsafe { *(result.output.as_ptr() as *const [G; OUT_106]) }; __ret } else { aiur_fn_106(__args, record, io_buffer, __cu)? } };
+            let __v_20: G = __r_arr[0];
+            let __v_21: G = __r_arr[1];
+            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_20.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).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_22: G = __loaded[0];
+            let __v_23: G = __loaded[1];
+            let __v_24: G = __loaded[2];
+            let __v_25: G = __loaded[3];
+            match __v_22.as_canonical_u64() {
+              2u64 => {
+                let __ret: [G; OUT_571] = [__v_24];
+                record.function_queries[571].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64()));
+                let __v_26: G = G::from_u64(1);
+                let __v_27: G = G::from_u64(1);
+                let __v_28: G = { let __values: [G; 3] = [__v_26, __v_27, __v_27]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_571] = [__v_28];
+                record.function_queries[571].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
               },
             }
           },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64()));
+            let __v_20: G = G::from_u64(1);
+            let __v_21: G = G::from_u64(1);
+            let __v_22: G = { let __values: [G; 3] = [__v_20, __v_21, __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 __ret: [G; OUT_571] = [__v_22];
+            record.function_queries[571].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
           },
         }
       },
+      _ => {
+        let __v_12: G = G::from_u64(1);
+        let __v_13: G = G::from_u64(1);
+        let __v_14: G = { let __values: [G; 3] = [__v_12, __v_13, __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 __ret: [G; OUT_571] = [__v_14];
+        record.function_queries[571].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
     }
   })
 }
 
-const INPUT_SIZE_654: usize = 2;
-const IN_654: usize = 2;
-const OUT_654: usize = 1;
-fn aiur_fn_654(
-  inp: [G; IN_654],
+const INPUT_SIZE_572: usize = 6;
+const IN_572: usize = 6;
+const OUT_572: usize = 1;
+fn aiur_fn_572(
+  inp: [G; IN_572],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_654], ExecError> {
+) -> Result<[G; OUT_572], 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);
-    match __v_2.as_canonical_u64() {
-      0u64 => {
-        let __v_3: G = G::from_u64(1);
-        let __ret: [G; OUT_654] = [__v_3];
-        record.function_queries[654].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    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 = (__v_3 + __v_4);
+    let __v_7: G = (__v_2 + __v_6);
+    let __v_8: G = (__v_1 + __v_7);
+    let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } else { aiur_fn_535(__args, record, io_buffer, __cu)? } };
+    let __v_9: 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_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: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].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];
+    match __v_10.as_canonical_u64() {
+      5u64 => {
+        let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[106].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_106] = unsafe { *(result.output.as_ptr() as *const [G; OUT_106]) }; __ret } else { aiur_fn_106(__args, record, io_buffer, __cu)? } };
+        let __v_14: G = __r_arr[0];
+        let __v_15: G = __r_arr[1];
+        let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_15, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } else { aiur_fn_721(__args, record, io_buffer, __cu)? } };
+        let __v_16: G = __r_arr[0];
+        let __v_17: G = (__v_2 + __v_3);
+        let __v_18: G = (__v_17 + __v_4);
+        let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_16, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[573].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_573] = unsafe { *(result.output.as_ptr() as *const [G; OUT_573]) }; __ret } else { aiur_fn_573(__args, record, io_buffer, __cu)? } };
+        let __v_19: G = __r_arr[0];
+        let __ret: [G; OUT_572] = [__v_19];
+        record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __v_3: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_1.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_3.as_canonical_u64() {
-          1u64 => {
-            let __v_4: G = G::from_u64(0);
-            let __ret: [G; OUT_654] = [__v_4];
-            record.function_queries[654].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          0u64 => {
-            let __v_4: G = G::from_u64(2);
-            let __ret: [G; OUT_654] = [__v_4];
-            record.function_queries[654].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
-          },
-        }
+        return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_655: usize = 2;
-const IN_655: usize = 2;
-const OUT_655: usize = 1;
-fn aiur_fn_655(
-  inp: [G; IN_655],
+const INPUT_SIZE_573: usize = 2;
+const IN_573: usize = 2;
+const OUT_573: usize = 1;
+fn aiur_fn_573(
+  inp: [G; IN_573],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_655], ExecError> {
+) -> Result<[G; OUT_573], 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() {
+    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_655] = [__v_1];
-        record.function_queries[655].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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_573] = [__v_7];
+        record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      _ => {
-        let __ret: [G; OUT_655] = [__v_0];
-        record.function_queries[655].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+      0u64 => {
+        let __v_5: G = G::from_u64(0);
+        let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_3, __v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = unsafe { *(result.output.as_ptr() as *const [G; OUT_317]) }; __ret } else { aiur_fn_317(__args, record, io_buffer, __cu)? } };
+        let __v_6: G = __r_arr[0];
+        let __v_7: G = G::from_u64(0);
+        if (__v_6 != __v_7) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_7.as_canonical_u64(), msg: Some("nested occurrence's parameter references a motive, minor, or index binder".to_string()) });
+        }
+        let __v_8: G = G::from_u64(0);
+        let __v_9: G = G::from_u64(0);
+        let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_3, __v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } else { aiur_fn_329(__args, record, io_buffer, __cu)? } };
+        let __v_10: G = __r_arr[0];
+        let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[573].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_573] = unsafe { *(result.output.as_ptr() as *const [G; OUT_573]) }; __ret } else { aiur_fn_573(__args, record, io_buffer, __cu)? } };
+        let __v_11: G = __r_arr[0];
+        let __v_12: G = { let __values: [G; 3] = [__v_8, __v_10, __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_573] = [__v_12];
+        record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
     }
   })
 }
 
-const INPUT_SIZE_656: usize = 0;
-const IN_656: usize = 0;
-const OUT_656: usize = 2;
-fn aiur_fn_656(
-  inp: [G; IN_656],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_656], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(0);
-    let __v_1: G = G::from_u64(1);
-    let __ret: [G; OUT_656] = [__v_0, __v_1];
-    record.function_queries[656].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_657: usize = 0;
-const IN_657: usize = 0;
-const OUT_657: usize = 2;
-fn aiur_fn_657(
-  inp: [G; IN_657],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_657], 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 __ret: [G; OUT_657] = [__v_0, __v_1];
-    record.function_queries[657].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_658: usize = 0;
-const IN_658: usize = 0;
-const OUT_658: usize = 2;
-fn aiur_fn_658(
-  inp: [G; IN_658],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_658], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(2);
-    let __v_1: G = G::from_u64(1);
-    let __ret: [G; OUT_658] = [__v_0, __v_1];
-    record.function_queries[658].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_659: usize = 4;
-const IN_659: usize = 4;
-const OUT_659: usize = 2;
-fn aiur_fn_659(
-  inp: [G; IN_659],
+const INPUT_SIZE_574: usize = 3;
+const IN_574: usize = 3;
+const OUT_574: usize = 1;
+fn aiur_fn_574(
+  inp: [G; IN_574],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_659], ExecError> {
+) -> Result<[G; OUT_574], 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_0.as_canonical_u64() {
-      1u64 => {
-        let __v_4: G = (__v_1 * __v_3);
-        let __ret: [G; OUT_659] = [__v_2, __v_4];
-        record.function_queries[659].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __v_3: G = (__v_1 - __v_2);
+    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; 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_574] = [__v_6];
+        record.function_queries[574].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __ret: [G; OUT_659] = [__v_0, __v_1];
-        record.function_queries[659].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __v_4: G = G::from_u64(0);
+        let __v_5: G = G::from_u64(4);
+        let __v_6: G = (__v_0 + __v_2);
+        let __v_7: G = G::from_u64(0);
+        let __v_8: G = { let __values: [G; 3] = [__v_5, __v_6, __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 __v_9: G = G::from_u64(1);
+        let __v_10: G = (__v_2 + __v_9);
+        let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_0, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } else { aiur_fn_574(__args, record, io_buffer, __cu)? } };
+        let __v_11: G = __r_arr[0];
+        let __v_12: G = { let __values: [G; 3] = [__v_4, __v_8, __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_574] = [__v_12];
+        record.function_queries[574].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_660: usize = 1;
-const IN_660: usize = 1;
-const OUT_660: usize = 2;
-fn aiur_fn_660(
-  inp: [G; IN_660],
+const INPUT_SIZE_575: usize = 2;
+const IN_575: usize = 2;
+const OUT_575: usize = 1;
+fn aiur_fn_575(
+  inp: [G; IN_575],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_660], ExecError> {
+) -> Result<[G; OUT_575], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __v_1: G = G::from_u64(1);
-    let __ret: [G; OUT_660] = [__v_0, __v_1];
-    record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
+    let __v_1: G = inp[1];
+    let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } else { aiur_fn_255(__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 = __r_arr[10];
+    let __v_13: G = __r_arr[11];
+    let __v_14: G = __r_arr[12];
+    let __v_15: G = __r_arr[13];
+    let __v_16: G = __r_arr[14];
+    let __v_17: G = __r_arr[15];
+    let __v_18: G = __r_arr[16];
+    let __v_19: G = __r_arr[17];
+    let __v_20: G = __r_arr[18];
+    let __v_21: G = __r_arr[19];
+    let __v_22: G = __r_arr[20];
+    let __v_23: G = __r_arr[21];
+    let __v_24: G = __r_arr[22];
+    let __v_25: G = __r_arr[23];
+    let __v_26: G = __r_arr[24];
+    let __v_27: G = __r_arr[25];
+    let __v_28: G = __r_arr[26];
+    let __v_29: G = __r_arr[27];
+    let __v_30: G = __r_arr[28];
+    let __v_31: G = __r_arr[29];
+    let __v_32: G = __r_arr[30];
+    let __v_33: G = __r_arr[31];
+    let __v_34: G = __r_arr[32];
+    let __v_35: G = __r_arr[33];
+    let __v_36: G = __r_arr[34];
+    let __v_37: G = __r_arr[35];
+    let __v_38: G = __r_arr[36];
+    let __v_39: G = __r_arr[37];
+    let __v_40: G = __r_arr[38];
+    let __v_41: G = __r_arr[39];
+    let __v_42: G = __r_arr[40];
+    let __v_43: G = __r_arr[41];
+    let __v_44: G = __r_arr[42];
+    let __v_45: G = __r_arr[43];
+    let __v_46: G = __r_arr[44];
+    let __v_47: G = __r_arr[45];
+    let __v_48: G = __r_arr[46];
+    let __v_49: G = __r_arr[47];
+    match __v_2.as_canonical_u64() {
+      _ => {
+        match __v_2.as_canonical_u64() {
+          8u64 => {
+            let __v_50: G = G::from_u64(0);
+            let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_3, __v_3, __v_0, __v_1, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[576].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_576] = unsafe { *(result.output.as_ptr() as *const [G; OUT_576]) }; __ret } else { aiur_fn_576(__args, record, io_buffer, __cu)? } };
+            let __v_51: G = __r_arr[0];
+            let __ret: [G; OUT_575] = [__v_51];
+            record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[258].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_258] = unsafe { *(result.output.as_ptr() as *const [G; OUT_258]) }; __ret } else { aiur_fn_258(__args, record, io_buffer, __cu)? } };
+            let __v_50: G = __r_arr[0];
+            let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_50.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+            let __v_51: G = __loaded[0];
+            let __v_52: G = __loaded[1];
+            let __v_53: G = __loaded[2];
+            let __v_54: G = __loaded[3];
+            let __v_55: G = __loaded[4];
+            let __v_56: G = __loaded[5];
+            let __v_57: G = __loaded[6];
+            let __v_58: G = __loaded[7];
+            let __v_59: G = __loaded[8];
+            let __v_60: G = __loaded[9];
+            let __v_61: G = __loaded[10];
+            let __v_62: G = __loaded[11];
+            match __v_51.as_canonical_u64() {
+              5u64 => {
+                let __v_63: G = G::from_u64(0);
+                let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_1, __v_52, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } else { aiur_fn_574(__args, record, io_buffer, __cu)? } };
+                let __v_64: G = __r_arr[0];
+                let __v_65: G = G::from_u64(0);
+                let __v_66: G = G::from_u64(0);
+                let __v_67: G = G::from_u64(1);
+                let __v_68: G = G::from_u64(1);
+                let __v_69: G = { let __values: [G; 3] = [__v_67, __v_68, __v_68]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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 = G::from_u64(1);
+                let __v_71: G = G::from_u64(1);
+                let __v_72: G = { let __values: [G; 6] = [__v_70, __v_71, __v_71, __v_71, __v_71, __v_71]; 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 __v_73: G = { let __values: [G; 6] = [__v_65, __v_0, __v_66, __v_69, __v_64, __v_72]; 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_575] = [__v_73];
+                record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                let __v_63: G = G::from_u64(1);
+                let __v_64: G = G::from_u64(1);
+                let __v_65: G = { let __values: [G; 6] = [__v_63, __v_64, __v_64, __v_64, __v_64, __v_64]; 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_575] = [__v_65];
+                record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+            }
+          },
+        }
+      },
+    }
   })
 }
 
-const INPUT_SIZE_661: usize = 2;
-const IN_661: usize = 2;
-const OUT_661: usize = 1;
-fn aiur_fn_661(
-  inp: [G; IN_661],
+const INPUT_SIZE_576: usize = 5;
+const IN_576: usize = 5;
+const OUT_576: usize = 1;
+fn aiur_fn_576(
+  inp: [G; IN_576],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_661], ExecError> {
+) -> Result<[G; OUT_576], 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_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_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 __v_6: G = G::from_u64(0);
-        let __ret: [G; OUT_661] = [__v_6];
-        record.function_queries[661].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; 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: 47 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 47] = __args[..47].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 __v_37: G = __loaded[32];
+    let __v_38: G = __loaded[33];
+    let __v_39: G = __loaded[34];
+    let __v_40: G = __loaded[35];
+    let __v_41: G = __loaded[36];
+    let __v_42: G = __loaded[37];
+    let __v_43: G = __loaded[38];
+    let __v_44: G = __loaded[39];
+    let __v_45: G = __loaded[40];
+    let __v_46: G = __loaded[41];
+    let __v_47: G = __loaded[42];
+    let __v_48: G = __loaded[43];
+    let __v_49: G = __loaded[44];
+    let __v_50: G = __loaded[45];
+    let __v_51: G = __loaded[46];
+    match __v_5.as_canonical_u64() {
+      1u64 => {
+        let __v_52: G = G::from_u64(1);
+        let __v_53: G = G::from_u64(1);
+        let __v_54: G = { let __values: [G; 6] = [__v_52, __v_53, __v_53, __v_53, __v_53, __v_53]; 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_576] = [__v_54];
+        record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __v_6: G = (__v_3 - __v_0);
         match __v_6.as_canonical_u64() {
-          0u64 => {
-            let __v_7: G = G::from_u64(1);
-            let __v_8: G = (__v_7 + __v_4);
-            let __ret: [G; OUT_661] = [__v_8];
-            record.function_queries[661].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+          1u64 => {
+            let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_0, __v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[266].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_266] = unsafe { *(result.output.as_ptr() as *const [G; OUT_266]) }; __ret } else { aiur_fn_266(__args, record, io_buffer, __cu)? } };
+            let __v_52: G = __r_arr[0];
+            let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[260].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_260] = unsafe { *(result.output.as_ptr() as *const [G; OUT_260]) }; __ret } else { aiur_fn_260(__args, record, io_buffer, __cu)? } };
+            let __v_53: G = __r_arr[0];
+            let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_53.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+            let __v_54: G = __loaded[0];
+            let __v_55: G = __loaded[1];
+            let __v_56: G = __loaded[2];
+            let __v_57: G = __loaded[3];
+            let __v_58: G = __loaded[4];
+            let __v_59: G = __loaded[5];
+            let __v_60: G = __loaded[6];
+            let __v_61: G = __loaded[7];
+            let __v_62: G = __loaded[8];
+            let __v_63: G = __loaded[9];
+            let __v_64: G = __loaded[10];
+            let __v_65: G = __loaded[11];
+            let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_54.as_canonical_u64() {
+  5u64 => {
+    break '__mc_0 [__v_55];
+  },
+  _ => {
+    let __v_66: G = G::from_u64(0);
+    break '__mc_0 [__v_66];
+  },
+}
+ };
+            let __v_66: G = __mc_out___mc_0[0];
+            let __v_67: G = G::from_u64(0);
+            let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_3, __v_66, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } else { aiur_fn_574(__args, record, io_buffer, __cu)? } };
+            let __v_68: G = __r_arr[0];
+            let __v_69: G = G::from_u64(0);
+            let __v_70: G = G::from_u64(0);
+            let __v_71: G = G::from_u64(1);
+            let __v_72: G = G::from_u64(1);
+            let __v_73: G = { let __values: [G; 3] = [__v_71, __v_72, __v_72]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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 = G::from_u64(1);
+            let __v_75: G = (__v_4 + __v_74);
+            let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_0, __v_51, __v_2, __v_3, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[576].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_576] = unsafe { *(result.output.as_ptr() as *const [G; OUT_576]) }; __ret } else { aiur_fn_576(__args, record, io_buffer, __cu)? } };
+            let __v_76: G = __r_arr[0];
+            let __v_77: G = { let __values: [G; 6] = [__v_69, __v_52, __v_70, __v_73, __v_68, __v_76]; 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_576] = [__v_77];
+            record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[661].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_661] = unsafe { *(result.output.as_ptr() as *const [G; OUT_661]) }; __ret } else { aiur_fn_661(__args, record, io_buffer, __cu)? } };
-            let __v_7: G = __r_arr[0];
-            let __ret: [G; OUT_661] = [__v_7];
-            record.function_queries[661].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __v_52: G = G::from_u64(1);
+            let __v_53: G = (__v_4 + __v_52);
+            let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_0, __v_51, __v_2, __v_3, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[576].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_576] = unsafe { *(result.output.as_ptr() as *const [G; OUT_576]) }; __ret } else { aiur_fn_576(__args, record, io_buffer, __cu)? } };
+            let __v_54: G = __r_arr[0];
+            let __ret: [G; OUT_576] = [__v_54];
+            record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+        return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_662: usize = 2;
-const IN_662: usize = 2;
-const OUT_662: usize = 1;
-fn aiur_fn_662(
-  inp: [G; IN_662],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_662], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    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_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];
-    let __v_12: G = __loaded[10];
-    let __v_13: G = __loaded[11];
-    let __v_14: G = __loaded[12];
-    let __v_15: G = __loaded[13];
-    let __v_16: G = __loaded[14];
-    let __v_17: G = __loaded[15];
-    let __v_18: G = __loaded[16];
-    let __v_19: G = __loaded[17];
-    let __v_20: G = __loaded[18];
-    let __v_21: G = __loaded[19];
-    let __v_22: G = __loaded[20];
-    let __v_23: G = __loaded[21];
-    let __v_24: G = __loaded[22];
-    let __v_25: G = __loaded[23];
-    let __v_26: G = __loaded[24];
-    let __v_27: G = __loaded[25];
-    let __v_28: G = __loaded[26];
-    let __v_29: G = __loaded[27];
-    let __v_30: G = __loaded[28];
-    let __v_31: G = __loaded[29];
-    let __v_32: G = __loaded[30];
-    let __v_33: 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_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 __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_2, __v_3, __v_4, __v_5, __v_34, __v_35, __v_36, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[663].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_663] = unsafe { *(result.output.as_ptr() as *const [G; OUT_663]) }; __ret } else { aiur_fn_663(__args, record, io_buffer, __cu)? } };
-    let __v_66: G = __r_arr[0];
-    let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_6, __v_7, __v_8, __v_9, __v_38, __v_39, __v_40, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[663].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_663] = unsafe { *(result.output.as_ptr() as *const [G; OUT_663]) }; __ret } else { aiur_fn_663(__args, record, io_buffer, __cu)? } };
-    let __v_67: G = __r_arr[0];
-    let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_10, __v_11, __v_12, __v_13, __v_42, __v_43, __v_44, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[663].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_663] = unsafe { *(result.output.as_ptr() as *const [G; OUT_663]) }; __ret } else { aiur_fn_663(__args, record, io_buffer, __cu)? } };
-    let __v_68: G = __r_arr[0];
-    let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_14, __v_15, __v_16, __v_17, __v_46, __v_47, __v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[663].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_663] = unsafe { *(result.output.as_ptr() as *const [G; OUT_663]) }; __ret } else { aiur_fn_663(__args, record, io_buffer, __cu)? } };
-    let __v_69: G = __r_arr[0];
-    let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_18, __v_19, __v_20, __v_21, __v_50, __v_51, __v_52, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[663].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_663] = unsafe { *(result.output.as_ptr() as *const [G; OUT_663]) }; __ret } else { aiur_fn_663(__args, record, io_buffer, __cu)? } };
-    let __v_70: G = __r_arr[0];
-    let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_22, __v_23, __v_24, __v_25, __v_54, __v_55, __v_56, __v_57]; let __cu = unconstrained; if let Some(result) = record.function_queries[663].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_663] = unsafe { *(result.output.as_ptr() as *const [G; OUT_663]) }; __ret } else { aiur_fn_663(__args, record, io_buffer, __cu)? } };
-    let __v_71: G = __r_arr[0];
-    let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_26, __v_27, __v_28, __v_29, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[663].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_663] = unsafe { *(result.output.as_ptr() as *const [G; OUT_663]) }; __ret } else { aiur_fn_663(__args, record, io_buffer, __cu)? } };
-    let __v_72: G = __r_arr[0];
-    let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_30, __v_31, __v_32, __v_33, __v_62, __v_63, __v_64, __v_65]; let __cu = unconstrained; if let Some(result) = record.function_queries[663].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_663] = unsafe { *(result.output.as_ptr() as *const [G; OUT_663]) }; __ret } else { aiur_fn_663(__args, record, io_buffer, __cu)? } };
-    let __v_73: G = __r_arr[0];
-    let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_72, __v_73]; let __cu = unconstrained; if let Some(result) = record.function_queries[655].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_655] = unsafe { *(result.output.as_ptr() as *const [G; OUT_655]) }; __ret } else { aiur_fn_655(__args, record, io_buffer, __cu)? } };
-    let __v_74: G = __r_arr[0];
-    let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_71, __v_74]; let __cu = unconstrained; if let Some(result) = record.function_queries[655].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_655] = unsafe { *(result.output.as_ptr() as *const [G; OUT_655]) }; __ret } else { aiur_fn_655(__args, record, io_buffer, __cu)? } };
-    let __v_75: G = __r_arr[0];
-    let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_70, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[655].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_655] = unsafe { *(result.output.as_ptr() as *const [G; OUT_655]) }; __ret } else { aiur_fn_655(__args, record, io_buffer, __cu)? } };
-    let __v_76: G = __r_arr[0];
-    let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_69, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[655].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_655] = unsafe { *(result.output.as_ptr() as *const [G; OUT_655]) }; __ret } else { aiur_fn_655(__args, record, io_buffer, __cu)? } };
-    let __v_77: G = __r_arr[0];
-    let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_68, __v_77]; let __cu = unconstrained; if let Some(result) = record.function_queries[655].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_655] = unsafe { *(result.output.as_ptr() as *const [G; OUT_655]) }; __ret } else { aiur_fn_655(__args, record, io_buffer, __cu)? } };
-    let __v_78: G = __r_arr[0];
-    let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_67, __v_78]; let __cu = unconstrained; if let Some(result) = record.function_queries[655].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_655] = unsafe { *(result.output.as_ptr() as *const [G; OUT_655]) }; __ret } else { aiur_fn_655(__args, record, io_buffer, __cu)? } };
-    let __v_79: G = __r_arr[0];
-    let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_66, __v_79]; let __cu = unconstrained; if let Some(result) = record.function_queries[655].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_655] = unsafe { *(result.output.as_ptr() as *const [G; OUT_655]) }; __ret } else { aiur_fn_655(__args, record, io_buffer, __cu)? } };
-    let __v_80: G = __r_arr[0];
-    let __ret: [G; OUT_662] = [__v_80];
-    record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_663: usize = 8;
-const IN_663: usize = 8;
-const OUT_663: usize = 1;
-fn aiur_fn_663(
-  inp: [G; IN_663],
+const INPUT_SIZE_577: usize = 3;
+const IN_577: usize = 3;
+const OUT_577: usize = 1;
+fn aiur_fn_577(
+  inp: [G; IN_577],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_663], ExecError> {
+) -> Result<[G; OUT_577], 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(16777216);
-    let __v_9: G = (__v_0 * __v_8);
-    let __v_10: G = G::from_u64(65536);
-    let __v_11: G = (__v_1 * __v_10);
-    let __v_12: G = G::from_u64(256);
-    let __v_13: G = (__v_2 * __v_12);
-    let __v_14: G = (__v_13 + __v_3);
-    let __v_15: G = (__v_11 + __v_14);
-    let __v_16: G = (__v_9 + __v_15);
-    let __v_17: G = G::from_u64(16777216);
-    let __v_18: G = (__v_4 * __v_17);
-    let __v_19: G = G::from_u64(65536);
-    let __v_20: G = (__v_5 * __v_19);
-    let __v_21: G = G::from_u64(256);
-    let __v_22: G = (__v_6 * __v_21);
-    let __v_23: G = (__v_22 + __v_7);
-    let __v_24: G = (__v_20 + __v_23);
-    let __v_25: G = (__v_18 + __v_24);
-    let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_16, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = unsafe { *(result.output.as_ptr() as *const [G; OUT_654]) }; __ret } else { aiur_fn_654(__args, record, io_buffer, __cu)? } };
-    let __v_26: G = __r_arr[0];
-    let __ret: [G; OUT_663] = [__v_26];
-    record.function_queries[663].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
+    let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; 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: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
+    let __v_3: G = __loaded[0];
+    let __v_4: G = __loaded[1];
+    let __v_5: G = __loaded[2];
+    let __v_6: G = __loaded[3];
+    let __v_7: G = __loaded[4];
+    let __v_8: G = __loaded[5];
+    match __v_3.as_canonical_u64() {
+      1u64 => {
+        let __v_9: G = G::from_u64(0);
+        let __ret: [G; OUT_577] = [__v_9];
+        record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      0u64 => {
+        match __v_5.as_canonical_u64() {
+          1u64 => {
+            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_9: G = __r_arr[0];
+            match __v_9.as_canonical_u64() {
+              1u64 => {
+                let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_6, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[580].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_580] = unsafe { *(result.output.as_ptr() as *const [G; OUT_580]) }; __ret } else { aiur_fn_580(__args, record, io_buffer, __cu)? } };
+                let __v_10: G = __r_arr[0];
+                match __v_10.as_canonical_u64() {
+                  1u64 => {
+                    let __v_11: G = G::from_u64(1);
+                    let __ret: [G; OUT_577] = [__v_11];
+                    record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
+                  },
+                  _ => {
+                    let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } else { aiur_fn_577(__args, record, io_buffer, __cu)? } };
+                    let __v_11: G = __r_arr[0];
+                    let __ret: [G; OUT_577] = [__v_11];
+                    record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
+                  },
+                }
+              },
+              _ => {
+                let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } else { aiur_fn_577(__args, record, io_buffer, __cu)? } };
+                let __v_10: G = __r_arr[0];
+                let __ret: [G; OUT_577] = [__v_10];
+                record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+            }
+          },
+          _ => {
+            let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } else { aiur_fn_577(__args, record, io_buffer, __cu)? } };
+            let __v_9: G = __r_arr[0];
+            let __ret: [G; OUT_577] = [__v_9];
+            record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
+      },
+    }
   })
 }
 
-const INPUT_SIZE_664: usize = 4;
-const IN_664: usize = 4;
-const OUT_664: usize = 2;
-fn aiur_fn_664(
-  inp: [G; IN_664],
+const INPUT_SIZE_578: usize = 2;
+const IN_578: usize = 2;
+const OUT_578: usize = 1;
+fn aiur_fn_578(
+  inp: [G; IN_578],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_664], ExecError> {
+) -> Result<[G; OUT_578], 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_1);
-    match __v_4.as_canonical_u64() {
+    let __v_2: G = (__v_0 - __v_1);
+    match __v_2.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[657].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_657] = unsafe { *(result.output.as_ptr() as *const [G; OUT_657]) }; __ret } else { aiur_fn_657(__args, record, io_buffer, __cu)? } };
-        let __v_5: G = __r_arr[0];
-        let __v_6: G = __r_arr[1];
-        let __ret: [G; OUT_664] = [__v_5, __v_6];
-        record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __v_3: G = G::from_u64(1);
+        let __ret: [G; OUT_578] = [__v_3];
+        record.function_queries[578].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[661].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_661] = unsafe { *(result.output.as_ptr() as *const [G; OUT_661]) }; __ret } else { aiur_fn_661(__args, record, io_buffer, __cu)? } };
-        let __v_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[661].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_661] = unsafe { *(result.output.as_ptr() as *const [G; OUT_661]) }; __ret } else { aiur_fn_661(__args, record, io_buffer, __cu)? } };
-        let __v_6: G = __r_arr[0];
-        match __v_5.as_canonical_u64() {
+        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_3: G = __loaded[0];
+        let __v_4: G = __loaded[1];
+        let __v_5: G = __loaded[2];
+        let __v_6: G = __loaded[3];
+        match __v_3.as_canonical_u64() {
           0u64 => {
-            match __v_6.as_canonical_u64() {
+            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_7: G = __loaded[0];
+            let __v_8: G = __loaded[1];
+            let __v_9: G = __loaded[2];
+            let __v_10: G = __loaded[3];
+            match __v_7.as_canonical_u64() {
               0u64 => {
-                let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_3, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-                let __v_7: G = __r_arr[0];
-                let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-                let __v_8: G = __r_arr[0];
-                let __r_arr: [G; OUT_662] = { let __args: [G; IN_662] = [__v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[662].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_662] = unsafe { *(result.output.as_ptr() as *const [G; OUT_662]) }; __ret } else { aiur_fn_662(__args, record, io_buffer, __cu)? } };
-                let __v_9: G = __r_arr[0];
-                let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } };
-                let __v_10: G = __r_arr[0];
-                let __v_11: G = __r_arr[1];
-                let __ret: [G; OUT_664] = [__v_10, __v_11];
-                record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __v_11: G = (__v_4 - __v_8);
+                match __v_11.as_canonical_u64() {
+                  0u64 => {
+                    let __v_12: G = G::from_u64(1);
+                    let __ret: [G; OUT_578] = [__v_12];
+                    record.function_queries[578].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
+                  },
+                  _ => {
+                    let __v_12: G = G::from_u64(0);
+                    let __ret: [G; OUT_578] = [__v_12];
+                    record.function_queries[578].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
+                  },
+                }
+              },
+              _ => {
+                let __v_11: G = G::from_u64(0);
+                let __ret: [G; OUT_578] = [__v_11];
+                record.function_queries[578].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+            }
+          },
+          1u64 => {
+            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_7: G = __loaded[0];
+            let __v_8: G = __loaded[1];
+            let __v_9: G = __loaded[2];
+            let __v_10: G = __loaded[3];
+            match __v_7.as_canonical_u64() {
+              1u64 => {
+                let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } else { aiur_fn_298(__args, record, io_buffer, __cu)? } };
+                let __v_11: G = __r_arr[0];
+                let __ret: [G; OUT_578] = [__v_11];
+                record.function_queries[578].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } };
-                let __v_7: G = __r_arr[0];
-                let __v_8: G = __r_arr[1];
-                let __ret: [G; OUT_664] = [__v_7, __v_8];
-                record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __v_11: G = G::from_u64(0);
+                let __ret: [G; OUT_578] = [__v_11];
+                record.function_queries[578].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
-          _ => {
-            match __v_6.as_canonical_u64() {
-              0u64 => {
-                let __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[656].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_656] = unsafe { *(result.output.as_ptr() as *const [G; OUT_656]) }; __ret } else { aiur_fn_656(__args, record, io_buffer, __cu)? } };
-                let __v_7: G = __r_arr[0];
-                let __v_8: G = __r_arr[1];
-                let __ret: [G; OUT_664] = [__v_7, __v_8];
-                record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+          2u64 => {
+            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_7: G = __loaded[0];
+            let __v_8: G = __loaded[1];
+            let __v_9: G = __loaded[2];
+            let __v_10: G = __loaded[3];
+            match __v_7.as_canonical_u64() {
+              2u64 => {
+                let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_11: G = __r_arr[0];
+                match __v_11.as_canonical_u64() {
+                  1u64 => {
+                    let __r_arr: [G; OUT_579] = { let __args: [G; IN_579] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[579].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_579] = unsafe { *(result.output.as_ptr() as *const [G; OUT_579]) }; __ret } else { aiur_fn_579(__args, record, io_buffer, __cu)? } };
+                    let __v_12: G = __r_arr[0];
+                    let __ret: [G; OUT_578] = [__v_12];
+                    record.function_queries[578].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
+                  },
+                  _ => {
+                    let __v_12: G = G::from_u64(0);
+                    let __ret: [G; OUT_578] = [__v_12];
+                    record.function_queries[578].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
+                  },
+                }
+              },
+              _ => {
+                let __v_11: G = G::from_u64(0);
+                let __ret: [G; OUT_578] = [__v_11];
+                record.function_queries[578].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
+            }
+          },
+          3u64 => {
+            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_7: G = __loaded[0];
+            let __v_8: G = __loaded[1];
+            let __v_9: G = __loaded[2];
+            let __v_10: G = __loaded[3];
+            match __v_7.as_canonical_u64() {
+              3u64 => {
+                let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[578].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_578] = unsafe { *(result.output.as_ptr() as *const [G; OUT_578]) }; __ret } else { aiur_fn_578(__args, record, io_buffer, __cu)? } };
+                let __v_11: G = __r_arr[0];
+                match __v_11.as_canonical_u64() {
+                  1u64 => {
+                    let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[578].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_578] = unsafe { *(result.output.as_ptr() as *const [G; OUT_578]) }; __ret } else { aiur_fn_578(__args, record, io_buffer, __cu)? } };
+                    let __v_12: G = __r_arr[0];
+                    let __ret: [G; OUT_578] = [__v_12];
+                    record.function_queries[578].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
+                  },
+                  _ => {
+                    let __v_12: G = G::from_u64(0);
+                    let __ret: [G; OUT_578] = [__v_12];
+                    record.function_queries[578].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
+                  },
+                }
+              },
               _ => {
-                let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = unsafe { *(result.output.as_ptr() as *const [G; OUT_654]) }; __ret } else { aiur_fn_654(__args, record, io_buffer, __cu)? } };
-                let __v_7: G = __r_arr[0];
-                let __v_8: G = G::from_u64(0);
-                let __ret: [G; OUT_664] = [__v_7, __v_8];
-                record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __v_11: G = G::from_u64(0);
+                let __ret: [G; OUT_578] = [__v_11];
+                record.function_queries[578].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+            }
+          },
+          4u64 => {
+            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_7: G = __loaded[0];
+            let __v_8: G = __loaded[1];
+            let __v_9: G = __loaded[2];
+            let __v_10: G = __loaded[3];
+            match __v_7.as_canonical_u64() {
+              4u64 => {
+                let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[578].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_578] = unsafe { *(result.output.as_ptr() as *const [G; OUT_578]) }; __ret } else { aiur_fn_578(__args, record, io_buffer, __cu)? } };
+                let __v_11: G = __r_arr[0];
+                match __v_11.as_canonical_u64() {
+                  1u64 => {
+                    let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[578].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_578] = unsafe { *(result.output.as_ptr() as *const [G; OUT_578]) }; __ret } else { aiur_fn_578(__args, record, io_buffer, __cu)? } };
+                    let __v_12: G = __r_arr[0];
+                    let __ret: [G; OUT_578] = [__v_12];
+                    record.function_queries[578].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
+                  },
+                  _ => {
+                    let __v_12: G = G::from_u64(0);
+                    let __ret: [G; OUT_578] = [__v_12];
+                    record.function_queries[578].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
+                  },
+                }
+              },
+              _ => {
+                let __v_11: G = G::from_u64(0);
+                let __ret: [G; OUT_578] = [__v_11];
+                record.function_queries[578].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+            }
+          },
+          5u64 => {
+            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_7: G = __loaded[0];
+            let __v_8: G = __loaded[1];
+            let __v_9: G = __loaded[2];
+            let __v_10: G = __loaded[3];
+            match __v_7.as_canonical_u64() {
+              5u64 => {
+                let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[578].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_578] = unsafe { *(result.output.as_ptr() as *const [G; OUT_578]) }; __ret } else { aiur_fn_578(__args, record, io_buffer, __cu)? } };
+                let __v_11: G = __r_arr[0];
+                match __v_11.as_canonical_u64() {
+                  1u64 => {
+                    let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[578].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_578] = unsafe { *(result.output.as_ptr() as *const [G; OUT_578]) }; __ret } else { aiur_fn_578(__args, record, io_buffer, __cu)? } };
+                    let __v_12: G = __r_arr[0];
+                    let __ret: [G; OUT_578] = [__v_12];
+                    record.function_queries[578].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
+                  },
+                  _ => {
+                    let __v_12: G = G::from_u64(0);
+                    let __ret: [G; OUT_578] = [__v_12];
+                    record.function_queries[578].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
+                  },
+                }
+              },
+              _ => {
+                let __v_11: G = G::from_u64(0);
+                let __ret: [G; OUT_578] = [__v_11];
+                record.function_queries[578].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+            }
+          },
+          6u64 => {
+            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_7: G = __loaded[0];
+            let __v_8: G = __loaded[1];
+            let __v_9: G = __loaded[2];
+            let __v_10: G = __loaded[3];
+            match __v_7.as_canonical_u64() {
+              6u64 => {
+                let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[578].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_578] = unsafe { *(result.output.as_ptr() as *const [G; OUT_578]) }; __ret } else { aiur_fn_578(__args, record, io_buffer, __cu)? } };
+                let __v_11: G = __r_arr[0];
+                match __v_11.as_canonical_u64() {
+                  1u64 => {
+                    let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[578].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_578] = unsafe { *(result.output.as_ptr() as *const [G; OUT_578]) }; __ret } else { aiur_fn_578(__args, record, io_buffer, __cu)? } };
+                    let __v_12: G = __r_arr[0];
+                    match __v_12.as_canonical_u64() {
+                      1u64 => {
+                        let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_6, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[578].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_578] = unsafe { *(result.output.as_ptr() as *const [G; OUT_578]) }; __ret } else { aiur_fn_578(__args, record, io_buffer, __cu)? } };
+                        let __v_13: G = __r_arr[0];
+                        let __ret: [G; OUT_578] = [__v_13];
+                        record.function_queries[578].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        return Ok(__ret);
+                      },
+                      _ => {
+                        let __v_13: G = G::from_u64(0);
+                        let __ret: [G; OUT_578] = [__v_13];
+                        record.function_queries[578].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        return Ok(__ret);
+                      },
+                    }
+                  },
+                  _ => {
+                    let __v_12: G = G::from_u64(0);
+                    let __ret: [G; OUT_578] = [__v_12];
+                    record.function_queries[578].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
+                  },
+                }
+              },
+              _ => {
+                let __v_11: G = G::from_u64(0);
+                let __ret: [G; OUT_578] = [__v_11];
+                record.function_queries[578].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+            }
+          },
+          7u64 => {
+            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_7: G = __loaded[0];
+            let __v_8: G = __loaded[1];
+            let __v_9: G = __loaded[2];
+            let __v_10: G = __loaded[3];
+            match __v_7.as_canonical_u64() {
+              7u64 => {
+                let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_4, __v_5, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[311].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_311] = unsafe { *(result.output.as_ptr() as *const [G; OUT_311]) }; __ret } else { aiur_fn_311(__args, record, io_buffer, __cu)? } };
+                let __v_11: G = __r_arr[0];
+                let __ret: [G; OUT_578] = [__v_11];
+                record.function_queries[578].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                let __v_11: G = G::from_u64(0);
+                let __ret: [G; OUT_578] = [__v_11];
+                record.function_queries[578].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+            }
+          },
+          8u64 => {
+            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_7: G = __loaded[0];
+            let __v_8: G = __loaded[1];
+            let __v_9: G = __loaded[2];
+            let __v_10: G = __loaded[3];
+            match __v_7.as_canonical_u64() {
+              8u64 => {
+                let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_11: G = __r_arr[0];
+                match __v_11.as_canonical_u64() {
+                  1u64 => {
+                    let __v_12: G = (__v_5 - __v_9);
+                    match __v_12.as_canonical_u64() {
+                      0u64 => {
+                        let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_6, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[578].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_578] = unsafe { *(result.output.as_ptr() as *const [G; OUT_578]) }; __ret } else { aiur_fn_578(__args, record, io_buffer, __cu)? } };
+                        let __v_13: G = __r_arr[0];
+                        let __ret: [G; OUT_578] = [__v_13];
+                        record.function_queries[578].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        return Ok(__ret);
+                      },
+                      _ => {
+                        let __v_13: G = G::from_u64(0);
+                        let __ret: [G; OUT_578] = [__v_13];
+                        record.function_queries[578].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        return Ok(__ret);
+                      },
+                    }
+                  },
+                  _ => {
+                    let __v_12: G = G::from_u64(0);
+                    let __ret: [G; OUT_578] = [__v_12];
+                    record.function_queries[578].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
+                  },
+                }
+              },
+              _ => {
+                let __v_11: G = G::from_u64(0);
+                let __ret: [G; OUT_578] = [__v_11];
+                record.function_queries[578].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
+          },
         }
       },
     }
   })
 }
 
-const INPUT_SIZE_665: usize = 2;
-const IN_665: usize = 2;
-const OUT_665: usize = 1;
-fn aiur_fn_665(
-  inp: [G; IN_665],
+const INPUT_SIZE_579: usize = 2;
+const IN_579: usize = 2;
+const OUT_579: usize = 1;
+fn aiur_fn_579(
+  inp: [G; IN_579],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_665], ExecError> {
+) -> Result<[G; OUT_579], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -55437,155 +48098,60 @@ fn aiur_fn_665(
     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 __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_5: G = __loaded[0];
-        let __v_6: G = __loaded[1];
-        let __v_7: G = __loaded[2];
-        match __v_5.as_canonical_u64() {
-          0u64 => {
-            let __v_8: G = G::from_u64(1);
-            let __ret: [G; OUT_665] = [__v_8];
-            record.function_queries[665].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_665] = [__v_8];
-            record.function_queries[665].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_5: G = __loaded[0];
-        let __v_6: G = __loaded[1];
-        let __v_7: G = __loaded[2];
-        match __v_5.as_canonical_u64() {
-          0u64 => {
-            let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_665] = [__v_8];
-            record.function_queries[665].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          1u64 => {
-            let __r_arr: [G; OUT_665] = { let __args: [G; IN_665] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[665].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_665] = unsafe { *(result.output.as_ptr() as *const [G; OUT_665]) }; __ret } else { aiur_fn_665(__args, record, io_buffer, __cu)? } };
-            let __v_8: G = __r_arr[0];
-            let __ret: [G; OUT_665] = [__v_8];
-            record.function_queries[665].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_665] = [__v_8];
-            record.function_queries[665].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-        }
-      },
-      2u64 => {
-        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_5: G = __loaded[0];
-        let __v_6: G = __loaded[1];
-        let __v_7: G = __loaded[2];
-        match __v_5.as_canonical_u64() {
-          0u64 => {
-            let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_665] = [__v_8];
-            record.function_queries[665].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          1u64 => {
-            let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_665] = [__v_8];
-            record.function_queries[665].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          2u64 => {
-            let __r_arr: [G; OUT_665] = { let __args: [G; IN_665] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[665].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_665] = unsafe { *(result.output.as_ptr() as *const [G; OUT_665]) }; __ret } else { aiur_fn_665(__args, record, io_buffer, __cu)? } };
-            let __v_8: G = __r_arr[0];
-            let __r_arr: [G; OUT_665] = { let __args: [G; IN_665] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[665].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_665] = unsafe { *(result.output.as_ptr() as *const [G; OUT_665]) }; __ret } else { aiur_fn_665(__args, record, io_buffer, __cu)? } };
-            let __v_9: G = __r_arr[0];
-            let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[655].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_655] = unsafe { *(result.output.as_ptr() as *const [G; OUT_655]) }; __ret } else { aiur_fn_655(__args, record, io_buffer, __cu)? } };
-            let __v_10: G = __r_arr[0];
-            let __ret: [G; OUT_665] = [__v_10];
-            record.function_queries[665].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_665] = [__v_8];
-            record.function_queries[665].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-        }
-      },
-      3u64 => {
+    match __v_2.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_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_5: G = __loaded[0];
         let __v_6: G = __loaded[1];
         let __v_7: G = __loaded[2];
         match __v_5.as_canonical_u64() {
-          0u64 => {
-            let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_665] = [__v_8];
-            record.function_queries[665].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
           1u64 => {
-            let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_665] = [__v_8];
-            record.function_queries[665].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          2u64 => {
-            let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_665] = [__v_8];
-            record.function_queries[665].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          3u64 => {
-            let __r_arr: [G; OUT_665] = { let __args: [G; IN_665] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[665].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_665] = unsafe { *(result.output.as_ptr() as *const [G; OUT_665]) }; __ret } else { aiur_fn_665(__args, record, io_buffer, __cu)? } };
-            let __v_8: G = __r_arr[0];
-            let __r_arr: [G; OUT_665] = { let __args: [G; IN_665] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[665].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_665] = unsafe { *(result.output.as_ptr() as *const [G; OUT_665]) }; __ret } else { aiur_fn_665(__args, record, io_buffer, __cu)? } };
-            let __v_9: G = __r_arr[0];
-            let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[655].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_655] = unsafe { *(result.output.as_ptr() as *const [G; OUT_655]) }; __ret } else { aiur_fn_655(__args, record, io_buffer, __cu)? } };
-            let __v_10: G = __r_arr[0];
-            let __ret: [G; OUT_665] = [__v_10];
-            record.function_queries[665].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __v_8: G = G::from_u64(1);
+            let __ret: [G; OUT_579] = [__v_8];
+            record.function_queries[579].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
-          4u64 => {
+          _ => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_665] = [__v_8];
-            record.function_queries[665].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_579] = [__v_8];
+            record.function_queries[579].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
-          },
         }
       },
-      4u64 => {
+      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_5: G = __loaded[0];
         let __v_6: G = __loaded[1];
         let __v_7: G = __loaded[2];
         match __v_5.as_canonical_u64() {
-          4u64 => {
-            let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = unsafe { *(result.output.as_ptr() as *const [G; OUT_654]) }; __ret } else { aiur_fn_654(__args, record, io_buffer, __cu)? } };
-            let __v_8: G = __r_arr[0];
-            let __ret: [G; OUT_665] = [__v_8];
-            record.function_queries[665].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+          1u64 => {
+            let __v_8: G = G::from_u64(0);
+            let __ret: [G; OUT_579] = [__v_8];
+            record.function_queries[579].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
+          0u64 => {
+            let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } else { aiur_fn_298(__args, record, io_buffer, __cu)? } };
+            let __v_8: G = __r_arr[0];
+            match __v_8.as_canonical_u64() {
+              1u64 => {
+                let __r_arr: [G; OUT_579] = { let __args: [G; IN_579] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[579].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_579] = unsafe { *(result.output.as_ptr() as *const [G; OUT_579]) }; __ret } else { aiur_fn_579(__args, record, io_buffer, __cu)? } };
+                let __v_9: G = __r_arr[0];
+                let __ret: [G; OUT_579] = [__v_9];
+                record.function_queries[579].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                let __v_9: G = G::from_u64(0);
+                let __ret: [G; OUT_579] = [__v_9];
+                record.function_queries[579].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+            }
+          },
           _ => {
-            let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_665] = [__v_8];
-            record.function_queries[665].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
+            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
           },
         }
       },
@@ -55596,15 +48162,15 @@ fn aiur_fn_665(
   })
 }
 
-const INPUT_SIZE_666: usize = 2;
-const IN_666: usize = 2;
-const OUT_666: usize = 1;
-fn aiur_fn_666(
-  inp: [G; IN_666],
+const INPUT_SIZE_580: usize = 2;
+const IN_580: usize = 2;
+const OUT_580: usize = 1;
+fn aiur_fn_580(
+  inp: [G; IN_580],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_666], ExecError> {
+) -> Result<[G; OUT_580], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -55621,14 +48187,14 @@ fn aiur_fn_666(
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(1);
-            let __ret: [G; OUT_666] = [__v_8];
-            record.function_queries[666].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_580] = [__v_8];
+            record.function_queries[580].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_666] = [__v_8];
-            record.function_queries[666].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_580] = [__v_8];
+            record.function_queries[580].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -55640,21 +48206,29 @@ fn aiur_fn_666(
         let __v_7: G = __loaded[2];
         match __v_5.as_canonical_u64() {
           1u64 => {
-            let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_666] = [__v_8];
-            record.function_queries[666].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __v_8: G = G::from_u64(0);
+            let __ret: [G; OUT_580] = [__v_8];
+            record.function_queries[580].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_665] = { let __args: [G; IN_665] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[665].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_665] = unsafe { *(result.output.as_ptr() as *const [G; OUT_665]) }; __ret } else { aiur_fn_665(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[578].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_578] = unsafe { *(result.output.as_ptr() as *const [G; OUT_578]) }; __ret } else { aiur_fn_578(__args, record, io_buffer, __cu)? } };
             let __v_8: G = __r_arr[0];
-            let __r_arr: [G; OUT_666] = { let __args: [G; IN_666] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[666].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_666] = unsafe { *(result.output.as_ptr() as *const [G; OUT_666]) }; __ret } else { aiur_fn_666(__args, record, io_buffer, __cu)? } };
-            let __v_9: G = __r_arr[0];
-            let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[655].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_655] = unsafe { *(result.output.as_ptr() as *const [G; OUT_655]) }; __ret } else { aiur_fn_655(__args, record, io_buffer, __cu)? } };
-            let __v_10: G = __r_arr[0];
-            let __ret: [G; OUT_666] = [__v_10];
-            record.function_queries[666].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
+            match __v_8.as_canonical_u64() {
+              1u64 => {
+                let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[580].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_580] = unsafe { *(result.output.as_ptr() as *const [G; OUT_580]) }; __ret } else { aiur_fn_580(__args, record, io_buffer, __cu)? } };
+                let __v_9: G = __r_arr[0];
+                let __ret: [G; OUT_580] = [__v_9];
+                record.function_queries[580].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                let __v_9: G = G::from_u64(0);
+                let __ret: [G; OUT_580] = [__v_9];
+                record.function_queries[580].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+            }
           },
           _ => {
             return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
@@ -55668,947 +48242,993 @@ fn aiur_fn_666(
   })
 }
 
-const INPUT_SIZE_667: usize = 2;
-const IN_667: usize = 2;
-const OUT_667: usize = 2;
-fn aiur_fn_667(
-  inp: [G; IN_667],
+const INPUT_SIZE_581: usize = 13;
+const IN_581: usize = 13;
+const OUT_581: usize = 1;
+fn aiur_fn_581(
+  inp: [G; IN_581],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_667], ExecError> {
+) -> Result<[G; OUT_581], 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_666] = { let __args: [G; IN_666] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[666].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_666] = unsafe { *(result.output.as_ptr() as *const [G; OUT_666]) }; __ret } else { aiur_fn_666(__args, record, io_buffer, __cu)? } };
-    let __v_2: G = __r_arr[0];
-    let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } };
-    let __v_3: G = __r_arr[0];
-    let __v_4: G = __r_arr[1];
-    let __ret: [G; OUT_667] = [__v_3, __v_4];
-    record.function_queries[667].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
+    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_0.as_canonical_u64() {
+      7u64 => {
+        let __r_arr: [G; OUT_572] = { let __args: [G; IN_572] = [__v_2, __v_3, __v_5, __v_6, __v_4, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[572].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_572] = unsafe { *(result.output.as_ptr() as *const [G; OUT_572]) }; __ret } else { aiur_fn_572(__args, record, io_buffer, __cu)? } };
+        let __v_13: G = __r_arr[0];
+        let __ret: [G; OUT_581] = [__v_13];
+        record.function_queries[581].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __v_13: G = G::from_u64(1);
+        let __v_14: G = G::from_u64(1);
+        let __v_15: G = { let __values: [G; 3] = [__v_13, __v_14, __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_581] = [__v_15];
+        record.function_queries[581].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+    }
   })
 }
 
-const INPUT_SIZE_668: usize = 2;
-const IN_668: usize = 2;
-const OUT_668: usize = 1;
-fn aiur_fn_668(
-  inp: [G; IN_668],
+const INPUT_SIZE_582: usize = 2;
+const IN_582: usize = 2;
+const OUT_582: usize = 1;
+fn aiur_fn_582(
+  inp: [G; IN_582],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_668], ExecError> {
+) -> Result<[G; OUT_582], 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 __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } else { aiur_fn_255(__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 = __r_arr[10];
+    let __v_13: G = __r_arr[11];
+    let __v_14: G = __r_arr[12];
+    let __v_15: G = __r_arr[13];
+    let __v_16: G = __r_arr[14];
+    let __v_17: G = __r_arr[15];
+    let __v_18: G = __r_arr[16];
+    let __v_19: G = __r_arr[17];
+    let __v_20: G = __r_arr[18];
+    let __v_21: G = __r_arr[19];
+    let __v_22: G = __r_arr[20];
+    let __v_23: G = __r_arr[21];
+    let __v_24: G = __r_arr[22];
+    let __v_25: G = __r_arr[23];
+    let __v_26: G = __r_arr[24];
+    let __v_27: G = __r_arr[25];
+    let __v_28: G = __r_arr[26];
+    let __v_29: G = __r_arr[27];
+    let __v_30: G = __r_arr[28];
+    let __v_31: G = __r_arr[29];
+    let __v_32: G = __r_arr[30];
+    let __v_33: G = __r_arr[31];
+    let __v_34: G = __r_arr[32];
+    let __v_35: G = __r_arr[33];
+    let __v_36: G = __r_arr[34];
+    let __v_37: G = __r_arr[35];
+    let __v_38: G = __r_arr[36];
+    let __v_39: G = __r_arr[37];
+    let __v_40: G = __r_arr[38];
+    let __v_41: G = __r_arr[39];
+    let __v_42: G = __r_arr[40];
+    let __v_43: G = __r_arr[41];
+    let __v_44: G = __r_arr[42];
+    let __v_45: G = __r_arr[43];
+    let __v_46: G = __r_arr[44];
+    let __v_47: G = __r_arr[45];
+    let __v_48: G = __r_arr[46];
+    let __v_49: G = __r_arr[47];
     match __v_2.as_canonical_u64() {
-      0u64 => {
-        let __v_3: G = G::from_u64(1);
-        let __ret: [G; OUT_668] = [__v_3];
-        record.function_queries[668].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
       _ => {
-        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_3: G = __loaded[0];
-        let __v_4: G = __loaded[1];
-        let __v_5: G = __loaded[2];
-        let __v_6: G = __loaded[3];
-        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_7: G = __loaded[0];
-        let __v_8: G = __loaded[1];
-        let __v_9: G = __loaded[2];
-        let __v_10: G = __loaded[3];
-        let __r_arr: [G; OUT_669] = { let __args: [G; IN_669] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[669].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_669] = unsafe { *(result.output.as_ptr() as *const [G; OUT_669]) }; __ret } else { aiur_fn_669(__args, record, io_buffer, __cu)? } };
-        let __v_11: G = __r_arr[0];
-        let __ret: [G; OUT_668] = [__v_11];
-        record.function_queries[668].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
+        match __v_2.as_canonical_u64() {
+          8u64 => {
+            let __v_50: G = G::from_u64(0);
+            let __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_3, __v_3, __v_0, __v_50, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[583].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_583] = unsafe { *(result.output.as_ptr() as *const [G; OUT_583]) }; __ret } else { aiur_fn_583(__args, record, io_buffer, __cu)? } };
+            let __v_51: G = __r_arr[0];
+            let __ret: [G; OUT_582] = [__v_51];
+            record.function_queries[582].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            let __ret: [G; OUT_582] = [__v_1];
+            record.function_queries[582].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+        }
       },
     }
   })
 }
 
-const INPUT_SIZE_669: usize = 8;
-const IN_669: usize = 8;
-const OUT_669: usize = 1;
-fn aiur_fn_669(
-  inp: [G; IN_669],
+const INPUT_SIZE_583: usize = 5;
+const IN_583: usize = 5;
+const OUT_583: usize = 1;
+fn aiur_fn_583(
+  inp: [G; IN_583],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_669], ExecError> {
+) -> Result<[G; OUT_583], 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];
-    match __v_0.as_canonical_u64() {
-      0u64 => {
-        match __v_4.as_canonical_u64() {
-          0u64 => {
-            let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = unsafe { *(result.output.as_ptr() as *const [G; OUT_654]) }; __ret } else { aiur_fn_654(__args, record, io_buffer, __cu)? } };
-            let __v_8: G = __r_arr[0];
-            let __ret: [G; OUT_669] = [__v_8];
-            record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_669] = [__v_8];
-            record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-        }
-      },
+    let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; 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: 47 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 47] = __args[..47].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 __v_37: G = __loaded[32];
+    let __v_38: G = __loaded[33];
+    let __v_39: G = __loaded[34];
+    let __v_40: G = __loaded[35];
+    let __v_41: G = __loaded[36];
+    let __v_42: G = __loaded[37];
+    let __v_43: G = __loaded[38];
+    let __v_44: G = __loaded[39];
+    let __v_45: G = __loaded[40];
+    let __v_46: G = __loaded[41];
+    let __v_47: G = __loaded[42];
+    let __v_48: G = __loaded[43];
+    let __v_49: G = __loaded[44];
+    let __v_50: G = __loaded[45];
+    let __v_51: G = __loaded[46];
+    match __v_5.as_canonical_u64() {
       1u64 => {
-        match __v_4.as_canonical_u64() {
-          0u64 => {
-            let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_669] = [__v_8];
-            record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          1u64 => {
-            let __r_arr: [G; OUT_665] = { let __args: [G; IN_665] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[665].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_665] = unsafe { *(result.output.as_ptr() as *const [G; OUT_665]) }; __ret } else { aiur_fn_665(__args, record, io_buffer, __cu)? } };
-            let __v_8: G = __r_arr[0];
-            let __ret: [G; OUT_669] = [__v_8];
-            record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_669] = [__v_8];
-            record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-        }
+        let __ret: [G; OUT_583] = [__v_4];
+        record.function_queries[583].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
-      2u64 => {
-        match __v_4.as_canonical_u64() {
-          0u64 => {
-            let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_669] = [__v_8];
-            record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          1u64 => {
-            let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_669] = [__v_8];
-            record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
+      0u64 => {
+        match __v_6.as_canonical_u64() {
           2u64 => {
-            let __r_arr: [G; OUT_666] = { let __args: [G; IN_666] = [__v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[666].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_666] = unsafe { *(result.output.as_ptr() as *const [G; OUT_666]) }; __ret } else { aiur_fn_666(__args, record, io_buffer, __cu)? } };
-            let __v_8: G = __r_arr[0];
-            let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = unsafe { *(result.output.as_ptr() as *const [G; OUT_654]) }; __ret } else { aiur_fn_654(__args, record, io_buffer, __cu)? } };
-            let __v_9: G = __r_arr[0];
-            let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[655].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_655] = unsafe { *(result.output.as_ptr() as *const [G; OUT_655]) }; __ret } else { aiur_fn_655(__args, record, io_buffer, __cu)? } };
-            let __v_10: G = __r_arr[0];
-            let __ret: [G; OUT_669] = [__v_10];
-            record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
+            let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[266].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_266] = unsafe { *(result.output.as_ptr() as *const [G; OUT_266]) }; __ret } else { aiur_fn_266(__args, record, io_buffer, __cu)? } };
+            let __v_52: G = __r_arr[0];
+            let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[258].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_258] = unsafe { *(result.output.as_ptr() as *const [G; OUT_258]) }; __ret } else { aiur_fn_258(__args, record, io_buffer, __cu)? } };
+            let __v_53: G = __r_arr[0];
+            let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_53.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+            let __v_54: G = __loaded[0];
+            let __v_55: G = __loaded[1];
+            let __v_56: G = __loaded[2];
+            let __v_57: G = __loaded[3];
+            let __v_58: G = __loaded[4];
+            let __v_59: G = __loaded[5];
+            let __v_60: G = __loaded[6];
+            let __v_61: G = __loaded[7];
+            let __v_62: G = __loaded[8];
+            let __v_63: G = __loaded[9];
+            let __v_64: G = __loaded[10];
+            let __v_65: G = __loaded[11];
+            match __v_54.as_canonical_u64() {
+              7u64 => {
+                let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_56, __v_57, __v_59, __v_60, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[570].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_570] = unsafe { *(result.output.as_ptr() as *const [G; OUT_570]) }; __ret } else { aiur_fn_570(__args, record, io_buffer, __cu)? } };
+                let __v_66: G = __r_arr[0];
+                let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_66]; let __cu = unconstrained; if let Some(result) = record.function_queries[258].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_258] = unsafe { *(result.output.as_ptr() as *const [G; OUT_258]) }; __ret } else { aiur_fn_258(__args, record, io_buffer, __cu)? } };
+                let __v_67: G = __r_arr[0];
+                let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_67.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+                let __v_68: G = __loaded[0];
+                let __v_69: G = __loaded[1];
+                let __v_70: G = __loaded[2];
+                let __v_71: G = __loaded[3];
+                let __v_72: G = __loaded[4];
+                let __v_73: G = __loaded[5];
+                let __v_74: G = __loaded[6];
+                let __v_75: G = __loaded[7];
+                let __v_76: G = __loaded[8];
+                let __v_77: G = __loaded[9];
+                let __v_78: G = __loaded[10];
+                let __v_79: G = __loaded[11];
+                match __v_68.as_canonical_u64() {
+                  5u64 => {
+                    let __ret: [G; OUT_583] = [__v_75];
+                    record.function_queries[583].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
+                  },
+                  _ => {
+                    let __ret: [G; OUT_583] = [__v_4];
+                    record.function_queries[583].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
+                  },
+                }
+              },
+              _ => {
+                let __ret: [G; OUT_583] = [__v_4];
+                record.function_queries[583].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+            }
           },
           _ => {
-            let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_669] = [__v_8];
-            record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __v_52: G = G::from_u64(1);
+            let __v_53: G = (__v_3 + __v_52);
+            let __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_0, __v_51, __v_2, __v_53, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[583].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_583] = unsafe { *(result.output.as_ptr() as *const [G; OUT_583]) }; __ret } else { aiur_fn_583(__args, record, io_buffer, __cu)? } };
+            let __v_54: G = __r_arr[0];
+            let __ret: [G; OUT_583] = [__v_54];
+            record.function_queries[583].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
-      3u64 => {
-        match __v_4.as_canonical_u64() {
-          0u64 => {
-            let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_669] = [__v_8];
-            record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          1u64 => {
-            let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_669] = [__v_8];
-            record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          2u64 => {
-            let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_669] = [__v_8];
-            record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          3u64 => {
-            let __r_arr: [G; OUT_668] = { let __args: [G; IN_668] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[668].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_668] = unsafe { *(result.output.as_ptr() as *const [G; OUT_668]) }; __ret } else { aiur_fn_668(__args, record, io_buffer, __cu)? } };
-            let __v_8: G = __r_arr[0];
-            let __r_arr: [G; OUT_668] = { let __args: [G; IN_668] = [__v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[668].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_668] = unsafe { *(result.output.as_ptr() as *const [G; OUT_668]) }; __ret } else { aiur_fn_668(__args, record, io_buffer, __cu)? } };
-            let __v_9: G = __r_arr[0];
-            let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[655].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_655] = unsafe { *(result.output.as_ptr() as *const [G; OUT_655]) }; __ret } else { aiur_fn_655(__args, record, io_buffer, __cu)? } };
-            let __v_10: G = __r_arr[0];
-            let __ret: [G; OUT_669] = [__v_10];
-            record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_669] = [__v_8];
-            record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-        }
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
       },
-      4u64 => {
-        match __v_4.as_canonical_u64() {
-          0u64 => {
-            let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_669] = [__v_8];
-            record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          1u64 => {
-            let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_669] = [__v_8];
-            record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          2u64 => {
-            let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_669] = [__v_8];
-            record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          3u64 => {
-            let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_669] = [__v_8];
-            record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          4u64 => {
-            let __r_arr: [G; OUT_668] = { let __args: [G; IN_668] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[668].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_668] = unsafe { *(result.output.as_ptr() as *const [G; OUT_668]) }; __ret } else { aiur_fn_668(__args, record, io_buffer, __cu)? } };
-            let __v_8: G = __r_arr[0];
-            let __r_arr: [G; OUT_668] = { let __args: [G; IN_668] = [__v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[668].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_668] = unsafe { *(result.output.as_ptr() as *const [G; OUT_668]) }; __ret } else { aiur_fn_668(__args, record, io_buffer, __cu)? } };
-            let __v_9: G = __r_arr[0];
-            let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[655].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_655] = unsafe { *(result.output.as_ptr() as *const [G; OUT_655]) }; __ret } else { aiur_fn_655(__args, record, io_buffer, __cu)? } };
-            let __v_10: G = __r_arr[0];
-            let __ret: [G; OUT_669] = [__v_10];
-            record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_669] = [__v_8];
-            record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-        }
+    }
+  })
+}
+
+const INPUT_SIZE_584: usize = 3;
+const IN_584: usize = 3;
+const OUT_584: usize = 1;
+fn aiur_fn_584(
+  inp: [G; IN_584],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_584], 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_582] = { let __args: [G; IN_582] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[582].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_582] = unsafe { *(result.output.as_ptr() as *const [G; OUT_582]) }; __ret } else { aiur_fn_582(__args, record, io_buffer, __cu)? } };
+    let __v_3: G = __r_arr[0];
+    let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_3, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[575].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_575] = unsafe { *(result.output.as_ptr() as *const [G; OUT_575]) }; __ret } else { aiur_fn_575(__args, record, io_buffer, __cu)? } };
+    let __v_4: G = __r_arr[0];
+    let __r_arr: [G; OUT_568] = { let __args: [G; IN_568] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[568].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_568] = unsafe { *(result.output.as_ptr() as *const [G; OUT_568]) }; __ret } else { aiur_fn_568(__args, record, io_buffer, __cu)? } };
+    let __v_5: G = __r_arr[0];
+    match __v_5.as_canonical_u64() {
+      0u64 => {
+        let __ret: [G; OUT_584] = [__v_4];
+        record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
-      5u64 => {
+      _ => {
+        let __r_arr: [G; OUT_585] = { let __args: [G; IN_585] = [__v_0, __v_3, __v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[585].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_585] = unsafe { *(result.output.as_ptr() as *const [G; OUT_585]) }; __ret } else { aiur_fn_585(__args, record, io_buffer, __cu)? } };
+        let __v_6: G = __r_arr[0];
+        let __ret: [G; OUT_584] = [__v_6];
+        record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_585: usize = 4;
+const IN_585: usize = 4;
+const OUT_585: usize = 1;
+fn aiur_fn_585(
+  inp: [G; IN_585],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_585], 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_255] = { let __args: [G; IN_255] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } else { aiur_fn_255(__args, record, io_buffer, __cu)? } };
+    let __v_4: G = __r_arr[0];
+    let __v_5: G = __r_arr[1];
+    let __v_6: G = __r_arr[2];
+    let __v_7: G = __r_arr[3];
+    let __v_8: G = __r_arr[4];
+    let __v_9: G = __r_arr[5];
+    let __v_10: G = __r_arr[6];
+    let __v_11: G = __r_arr[7];
+    let __v_12: G = __r_arr[8];
+    let __v_13: G = __r_arr[9];
+    let __v_14: G = __r_arr[10];
+    let __v_15: G = __r_arr[11];
+    let __v_16: G = __r_arr[12];
+    let __v_17: G = __r_arr[13];
+    let __v_18: G = __r_arr[14];
+    let __v_19: G = __r_arr[15];
+    let __v_20: G = __r_arr[16];
+    let __v_21: G = __r_arr[17];
+    let __v_22: G = __r_arr[18];
+    let __v_23: G = __r_arr[19];
+    let __v_24: G = __r_arr[20];
+    let __v_25: G = __r_arr[21];
+    let __v_26: G = __r_arr[22];
+    let __v_27: G = __r_arr[23];
+    let __v_28: G = __r_arr[24];
+    let __v_29: G = __r_arr[25];
+    let __v_30: G = __r_arr[26];
+    let __v_31: G = __r_arr[27];
+    let __v_32: G = __r_arr[28];
+    let __v_33: G = __r_arr[29];
+    let __v_34: G = __r_arr[30];
+    let __v_35: G = __r_arr[31];
+    let __v_36: G = __r_arr[32];
+    let __v_37: G = __r_arr[33];
+    let __v_38: G = __r_arr[34];
+    let __v_39: G = __r_arr[35];
+    let __v_40: G = __r_arr[36];
+    let __v_41: G = __r_arr[37];
+    let __v_42: G = __r_arr[38];
+    let __v_43: G = __r_arr[39];
+    let __v_44: G = __r_arr[40];
+    let __v_45: G = __r_arr[41];
+    let __v_46: G = __r_arr[42];
+    let __v_47: G = __r_arr[43];
+    let __v_48: G = __r_arr[44];
+    let __v_49: G = __r_arr[45];
+    let __v_50: G = __r_arr[46];
+    let __v_51: G = __r_arr[47];
+    match __v_4.as_canonical_u64() {
+      _ => {
         match __v_4.as_canonical_u64() {
-          0u64 => {
-            let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_669] = [__v_8];
-            record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          1u64 => {
-            let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_669] = [__v_8];
-            record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          2u64 => {
-            let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_669] = [__v_8];
-            record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          3u64 => {
-            let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_669] = [__v_8];
-            record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          4u64 => {
-            let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_669] = [__v_8];
-            record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          5u64 => {
-            let __r_arr: [G; OUT_668] = { let __args: [G; IN_668] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[668].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_668] = unsafe { *(result.output.as_ptr() as *const [G; OUT_668]) }; __ret } else { aiur_fn_668(__args, record, io_buffer, __cu)? } };
-            let __v_8: G = __r_arr[0];
-            let __r_arr: [G; OUT_668] = { let __args: [G; IN_668] = [__v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[668].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_668] = unsafe { *(result.output.as_ptr() as *const [G; OUT_668]) }; __ret } else { aiur_fn_668(__args, record, io_buffer, __cu)? } };
-            let __v_9: G = __r_arr[0];
-            let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[655].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_655] = unsafe { *(result.output.as_ptr() as *const [G; OUT_655]) }; __ret } else { aiur_fn_655(__args, record, io_buffer, __cu)? } };
-            let __v_10: G = __r_arr[0];
-            let __ret: [G; OUT_669] = [__v_10];
-            record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+          8u64 => {
+            let __v_52: G = G::from_u64(0);
+            let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_5, __v_5, __v_0, __v_1, __v_2, __v_3, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[586].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_586] = unsafe { *(result.output.as_ptr() as *const [G; OUT_586]) }; __ret } else { aiur_fn_586(__args, record, io_buffer, __cu)? } };
+            let __v_53: G = __r_arr[0];
+            let __ret: [G; OUT_585] = [__v_53];
+            record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_669] = [__v_8];
-            record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_585] = [__v_3];
+            record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
-      6u64 => {
-        match __v_4.as_canonical_u64() {
-          0u64 => {
-            let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_669] = [__v_8];
-            record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          1u64 => {
-            let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_669] = [__v_8];
-            record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
+    }
+  })
+}
+
+const INPUT_SIZE_586: usize = 7;
+const IN_586: usize = 7;
+const OUT_586: usize = 1;
+fn aiur_fn_586(
+  inp: [G; IN_586],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_586], 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; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; 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: 47 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 47] = __args[..47].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];
+    let __v_17: G = __loaded[10];
+    let __v_18: G = __loaded[11];
+    let __v_19: G = __loaded[12];
+    let __v_20: G = __loaded[13];
+    let __v_21: G = __loaded[14];
+    let __v_22: G = __loaded[15];
+    let __v_23: G = __loaded[16];
+    let __v_24: G = __loaded[17];
+    let __v_25: G = __loaded[18];
+    let __v_26: G = __loaded[19];
+    let __v_27: G = __loaded[20];
+    let __v_28: G = __loaded[21];
+    let __v_29: G = __loaded[22];
+    let __v_30: G = __loaded[23];
+    let __v_31: G = __loaded[24];
+    let __v_32: G = __loaded[25];
+    let __v_33: G = __loaded[26];
+    let __v_34: G = __loaded[27];
+    let __v_35: G = __loaded[28];
+    let __v_36: G = __loaded[29];
+    let __v_37: G = __loaded[30];
+    let __v_38: G = __loaded[31];
+    let __v_39: G = __loaded[32];
+    let __v_40: G = __loaded[33];
+    let __v_41: G = __loaded[34];
+    let __v_42: G = __loaded[35];
+    let __v_43: G = __loaded[36];
+    let __v_44: G = __loaded[37];
+    let __v_45: G = __loaded[38];
+    let __v_46: G = __loaded[39];
+    let __v_47: G = __loaded[40];
+    let __v_48: G = __loaded[41];
+    let __v_49: G = __loaded[42];
+    let __v_50: G = __loaded[43];
+    let __v_51: G = __loaded[44];
+    let __v_52: G = __loaded[45];
+    let __v_53: G = __loaded[46];
+    match __v_7.as_canonical_u64() {
+      1u64 => {
+        let __ret: [G; OUT_586] = [__v_5];
+        record.function_queries[586].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      0u64 => {
+        match __v_8.as_canonical_u64() {
           2u64 => {
-            let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_669] = [__v_8];
-            record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          3u64 => {
-            let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_669] = [__v_8];
-            record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          4u64 => {
-            let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_669] = [__v_8];
-            record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          5u64 => {
-            let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_669] = [__v_8];
-            record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          6u64 => {
-            let __r_arr: [G; OUT_668] = { let __args: [G; IN_668] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[668].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_668] = unsafe { *(result.output.as_ptr() as *const [G; OUT_668]) }; __ret } else { aiur_fn_668(__args, record, io_buffer, __cu)? } };
-            let __v_8: G = __r_arr[0];
-            let __r_arr: [G; OUT_668] = { let __args: [G; IN_668] = [__v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[668].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_668] = unsafe { *(result.output.as_ptr() as *const [G; OUT_668]) }; __ret } else { aiur_fn_668(__args, record, io_buffer, __cu)? } };
-            let __v_9: G = __r_arr[0];
-            let __r_arr: [G; OUT_668] = { let __args: [G; IN_668] = [__v_3, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[668].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_668] = unsafe { *(result.output.as_ptr() as *const [G; OUT_668]) }; __ret } else { aiur_fn_668(__args, record, io_buffer, __cu)? } };
-            let __v_10: G = __r_arr[0];
-            let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[655].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_655] = unsafe { *(result.output.as_ptr() as *const [G; OUT_655]) }; __ret } else { aiur_fn_655(__args, record, io_buffer, __cu)? } };
-            let __v_11: G = __r_arr[0];
-            let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[655].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_655] = unsafe { *(result.output.as_ptr() as *const [G; OUT_655]) }; __ret } else { aiur_fn_655(__args, record, io_buffer, __cu)? } };
-            let __v_12: G = __r_arr[0];
-            let __ret: [G; OUT_669] = [__v_12];
-            record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
+            let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_0, __v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[266].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_266] = unsafe { *(result.output.as_ptr() as *const [G; OUT_266]) }; __ret } else { aiur_fn_266(__args, record, io_buffer, __cu)? } };
+            let __v_54: G = __r_arr[0];
+            let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[258].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_258] = unsafe { *(result.output.as_ptr() as *const [G; OUT_258]) }; __ret } else { aiur_fn_258(__args, record, io_buffer, __cu)? } };
+            let __v_55: G = __r_arr[0];
+            let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_55.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+            let __v_56: G = __loaded[0];
+            let __v_57: G = __loaded[1];
+            let __v_58: G = __loaded[2];
+            let __v_59: G = __loaded[3];
+            let __v_60: G = __loaded[4];
+            let __v_61: G = __loaded[5];
+            let __v_62: G = __loaded[6];
+            let __v_63: G = __loaded[7];
+            let __v_64: G = __loaded[8];
+            let __v_65: G = __loaded[9];
+            let __v_66: G = __loaded[10];
+            let __v_67: G = __loaded[11];
+            let __mc_out___mc_0: [G; 5] = '__mc_0: { match __v_56.as_canonical_u64() {
+  7u64 => {
+    let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_58, __v_59, __v_61, __v_62, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[570].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_570] = unsafe { *(result.output.as_ptr() as *const [G; OUT_570]) }; __ret } else { aiur_fn_570(__args, record, io_buffer, __cu)? } };
+    let __v_68: G = __r_arr[0];
+    let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_68]; let __cu = unconstrained; if let Some(result) = record.function_queries[258].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_258] = unsafe { *(result.output.as_ptr() as *const [G; OUT_258]) }; __ret } else { aiur_fn_258(__args, record, io_buffer, __cu)? } };
+    let __v_69: G = __r_arr[0];
+    let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; 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: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+    let __v_70: G = __loaded[0];
+    let __v_71: G = __loaded[1];
+    let __v_72: G = __loaded[2];
+    let __v_73: G = __loaded[3];
+    let __v_74: G = __loaded[4];
+    let __v_75: G = __loaded[5];
+    let __v_76: G = __loaded[6];
+    let __v_77: G = __loaded[7];
+    let __v_78: G = __loaded[8];
+    let __v_79: G = __loaded[9];
+    let __v_80: G = __loaded[10];
+    let __v_81: G = __loaded[11];
+    match __v_70.as_canonical_u64() {
+      5u64 => {
+        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_77, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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];
+        match __v_82.as_canonical_u64() {
+          1u64 => {
+            let __v_83: G = G::from_u64(0);
+            let __v_84: G = G::from_u64(0);
+            break '__mc_0 [__v_83, __v_68, __v_84, __v_73, __v_71];
           },
           _ => {
-            let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_669] = [__v_8];
-            record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
+            let __v_83: G = G::from_u64(1);
+            let __v_84: G = G::from_u64(1);
+            break '__mc_0 [__v_83, __v_68, __v_84, __v_73, __v_71];
           },
         }
       },
-      7u64 => {
-        match __v_4.as_canonical_u64() {
-          8u64 => {
-            let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_669] = [__v_8];
-            record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          7u64 => {
-            let __r_arr: [G; OUT_672] = { let __args: [G; IN_672] = [__v_1, __v_2, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[672].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_672] = unsafe { *(result.output.as_ptr() as *const [G; OUT_672]) }; __ret } else { aiur_fn_672(__args, record, io_buffer, __cu)? } };
-            let __v_8: G = __r_arr[0];
-            let __ret: [G; OUT_669] = [__v_8];
-            record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_669] = [__v_8];
-            record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-        }
+      _ => {
+        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);
+        break '__mc_0 [__v_82, __v_68, __v_83, __v_84, __v_85];
       },
-      8u64 => {
-        match __v_4.as_canonical_u64() {
-          8u64 => {
-            let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = unsafe { *(result.output.as_ptr() as *const [G; OUT_654]) }; __ret } else { aiur_fn_654(__args, record, io_buffer, __cu)? } };
-            let __v_8: G = __r_arr[0];
-            let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = unsafe { *(result.output.as_ptr() as *const [G; OUT_654]) }; __ret } else { aiur_fn_654(__args, record, io_buffer, __cu)? } };
-            let __v_9: G = __r_arr[0];
-            let __r_arr: [G; OUT_668] = { let __args: [G; IN_668] = [__v_3, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[668].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_668] = unsafe { *(result.output.as_ptr() as *const [G; OUT_668]) }; __ret } else { aiur_fn_668(__args, record, io_buffer, __cu)? } };
-            let __v_10: G = __r_arr[0];
-            let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[655].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_655] = unsafe { *(result.output.as_ptr() as *const [G; OUT_655]) }; __ret } else { aiur_fn_655(__args, record, io_buffer, __cu)? } };
-            let __v_11: G = __r_arr[0];
-            let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[655].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_655] = unsafe { *(result.output.as_ptr() as *const [G; OUT_655]) }; __ret } else { aiur_fn_655(__args, record, io_buffer, __cu)? } };
-            let __v_12: G = __r_arr[0];
-            let __ret: [G; OUT_669] = [__v_12];
-            record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
+    }
+  },
+  _ => {
+    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);
+    break '__mc_0 [__v_68, __v_3, __v_69, __v_70, __v_71];
+  },
+}
+ };
+            let __v_68: G = __mc_out___mc_0[0];
+            let __v_69: G = __mc_out___mc_0[1];
+            let __v_70: G = __mc_out___mc_0[2];
+            let __v_71: G = __mc_out___mc_0[3];
+            let __v_72: G = __mc_out___mc_0[4];
+            match __v_68.as_canonical_u64() {
+              0u64 => {
+                let __v_73: G = G::from_u64(1);
+                let __v_74: G = (__v_6 + __v_73);
+                let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_5, __v_74]; let __cu = unconstrained; if let Some(result) = record.function_queries[586].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_586] = unsafe { *(result.output.as_ptr() as *const [G; OUT_586]) }; __ret } else { aiur_fn_586(__args, record, io_buffer, __cu)? } };
+                let __v_75: G = __r_arr[0];
+                let __ret: [G; OUT_586] = [__v_75];
+                record.function_queries[586].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__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_71]; let __cu = unconstrained; if let Some(result) = record.function_queries[581].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_581] = unsafe { *(result.output.as_ptr() as *const [G; OUT_581]) }; __ret } else { aiur_fn_581(__args, record, io_buffer, __cu)? } };
+                let __v_73: G = __r_arr[0];
+                let __r_arr: [G; OUT_571] = { let __args: [G; IN_571] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[571].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_571] = unsafe { *(result.output.as_ptr() as *const [G; OUT_571]) }; __ret } else { aiur_fn_571(__args, record, io_buffer, __cu)? } };
+                let __v_74: G = __r_arr[0];
+                let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_5, __v_69, __v_73]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } else { aiur_fn_577(__args, record, io_buffer, __cu)? } };
+                let __v_75: G = __r_arr[0];
+                match __v_75.as_canonical_u64() {
+                  1u64 => {
+                    let __v_76: G = G::from_u64(1);
+                    let __v_77: G = (__v_6 + __v_76);
+                    let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_5, __v_77]; let __cu = unconstrained; if let Some(result) = record.function_queries[586].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_586] = unsafe { *(result.output.as_ptr() as *const [G; OUT_586]) }; __ret } else { aiur_fn_586(__args, record, io_buffer, __cu)? } };
+                    let __v_78: G = __r_arr[0];
+                    let __ret: [G; OUT_586] = [__v_78];
+                    record.function_queries[586].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
+                  },
+                  _ => {
+                    let __v_76: G = G::from_u64(1);
+                    let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_5, __v_69, __v_76, __v_73, __v_74]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } };
+                    let __v_77: G = __r_arr[0];
+                    let __v_78: G = G::from_u64(1);
+                    let __v_79: G = (__v_6 + __v_78);
+                    let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_77, __v_79]; let __cu = unconstrained; if let Some(result) = record.function_queries[586].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_586] = unsafe { *(result.output.as_ptr() as *const [G; OUT_586]) }; __ret } else { aiur_fn_586(__args, record, io_buffer, __cu)? } };
+                    let __v_80: G = __r_arr[0];
+                    let __ret: [G; OUT_586] = [__v_80];
+                    record.function_queries[586].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
+                  },
+                }
+              },
+            }
           },
           _ => {
-            let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_669] = [__v_8];
-            record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __v_54: G = G::from_u64(1);
+            let __v_55: G = (__v_6 + __v_54);
+            let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_5, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[586].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_586] = unsafe { *(result.output.as_ptr() as *const [G; OUT_586]) }; __ret } else { aiur_fn_586(__args, record, io_buffer, __cu)? } };
+            let __v_56: G = __r_arr[0];
+            let __ret: [G; OUT_586] = [__v_56];
+            record.function_queries[586].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64()));
+        return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_670: usize = 4;
-const IN_670: usize = 4;
-const OUT_670: usize = 2;
-fn aiur_fn_670(
-  inp: [G; IN_670],
+const INPUT_SIZE_587: usize = 3;
+const IN_587: usize = 3;
+const OUT_587: usize = 2;
+fn aiur_fn_587(
+  inp: [G; IN_587],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_670], ExecError> {
+) -> Result<[G; OUT_587], 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_1);
-    match __v_4.as_canonical_u64() {
-      0u64 => {
-        let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[657].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_657] = unsafe { *(result.output.as_ptr() as *const [G; OUT_657]) }; __ret } else { aiur_fn_657(__args, record, io_buffer, __cu)? } };
-        let __v_5: G = __r_arr[0];
-        let __v_6: G = __r_arr[1];
-        let __ret: [G; OUT_670] = [__v_5, __v_6];
-        record.function_queries[670].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; 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: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
+    let __v_3: G = __loaded[0];
+    let __v_4: G = __loaded[1];
+    let __v_5: G = __loaded[2];
+    let __v_6: G = __loaded[3];
+    let __v_7: G = __loaded[4];
+    let __v_8: G = __loaded[5];
+    match __v_3.as_canonical_u64() {
+      1u64 => {
+        let __v_9: G = G::from_u64(0);
+        let __v_10: G = G::from_u64(0);
+        let __ret: [G; OUT_587] = [__v_9, __v_10];
+        record.function_queries[587].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
+      0u64 => {
+        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_9: G = __r_arr[0];
+        match __v_9.as_canonical_u64() {
+          1u64 => {
+            let __v_10: G = G::from_u64(1);
+            let __ret: [G; OUT_587] = [__v_10, __v_2];
+            record.function_queries[587].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            let __v_10: G = G::from_u64(1);
+            let __v_11: G = (__v_2 + __v_10);
+            let __r_arr: [G; OUT_587] = { let __args: [G; IN_587] = [__v_8, __v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[587].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_587] = unsafe { *(result.output.as_ptr() as *const [G; OUT_587]) }; __ret } else { aiur_fn_587(__args, record, io_buffer, __cu)? } };
+            let __v_12: G = __r_arr[0];
+            let __v_13: G = __r_arr[1];
+            let __ret: [G; OUT_587] = [__v_12, __v_13];
+            record.function_queries[587].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+        }
+      },
       _ => {
-        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_5: G = __loaded[0];
-        let __v_6: G = __loaded[1];
-        let __v_7: G = __loaded[2];
-        let __v_8: G = __loaded[3];
-        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_9: G = __loaded[0];
-        let __v_10: G = __loaded[1];
-        let __v_11: G = __loaded[2];
-        let __v_12: G = __loaded[3];
-        let __r_arr: [G; OUT_671] = { let __args: [G; IN_671] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[671].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_671] = unsafe { *(result.output.as_ptr() as *const [G; OUT_671]) }; __ret } else { aiur_fn_671(__args, record, io_buffer, __cu)? } };
-        let __v_13: G = __r_arr[0];
-        let __v_14: G = __r_arr[1];
-        let __ret: [G; OUT_670] = [__v_13, __v_14];
-        record.function_queries[670].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
+        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_671: usize = 10;
-const IN_671: usize = 10;
-const OUT_671: usize = 2;
-fn aiur_fn_671(
-  inp: [G; IN_671],
+const INPUT_SIZE_588: usize = 5;
+const IN_588: usize = 5;
+const OUT_588: usize = 2;
+fn aiur_fn_588(
+  inp: [G; IN_588],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_671], ExecError> {
+) -> Result<[G; OUT_588], 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_0.as_canonical_u64() {
-      0u64 => {
-        match __v_4.as_canonical_u64() {
-          0u64 => {
-            let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = unsafe { *(result.output.as_ptr() as *const [G; OUT_654]) }; __ret } else { aiur_fn_654(__args, record, io_buffer, __cu)? } };
-            let __v_10: G = __r_arr[0];
-            let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } };
-            let __v_11: G = __r_arr[0];
-            let __v_12: G = __r_arr[1];
-            let __ret: [G; OUT_671] = [__v_11, __v_12];
-            record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            let __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[656].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_656] = unsafe { *(result.output.as_ptr() as *const [G; OUT_656]) }; __ret } else { aiur_fn_656(__args, record, io_buffer, __cu)? } };
-            let __v_10: G = __r_arr[0];
-            let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_671] = [__v_10, __v_11];
-            record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-        }
-      },
+    let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; 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: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].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];
+    match __v_5.as_canonical_u64() {
       1u64 => {
-        match __v_4.as_canonical_u64() {
-          0u64 => {
-            let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } };
-            let __v_10: G = __r_arr[0];
-            let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_671] = [__v_10, __v_11];
-            record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          1u64 => {
-            let __r_arr: [G; OUT_665] = { let __args: [G; IN_665] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[665].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_665] = unsafe { *(result.output.as_ptr() as *const [G; OUT_665]) }; __ret } else { aiur_fn_665(__args, record, io_buffer, __cu)? } };
-            let __v_10: G = __r_arr[0];
-            let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } };
-            let __v_11: G = __r_arr[0];
-            let __v_12: G = __r_arr[1];
-            let __ret: [G; OUT_671] = [__v_11, __v_12];
-            record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            let __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[656].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_656] = unsafe { *(result.output.as_ptr() as *const [G; OUT_656]) }; __ret } else { aiur_fn_656(__args, record, io_buffer, __cu)? } };
-            let __v_10: G = __r_arr[0];
-            let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_671] = [__v_10, __v_11];
-            record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-        }
+        let __v_11: G = G::from_u64(0);
+        let __v_12: G = G::from_u64(0);
+        let __ret: [G; OUT_588] = [__v_11, __v_12];
+        record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
-      2u64 => {
-        match __v_4.as_canonical_u64() {
-          0u64 => {
-            let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } };
-            let __v_10: G = __r_arr[0];
-            let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_671] = [__v_10, __v_11];
-            record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
+      0u64 => {
+        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_11: G = __r_arr[0];
+        let __v_12: G = (__v_2 - __v_7);
+        let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_12.as_canonical_u64() {
+  0u64 => {
+    let __v_13: G = G::from_u64(1);
+    break '__mc_0 [__v_13];
+  },
+  _ => {
+    let __v_13: G = G::from_u64(0);
+    break '__mc_0 [__v_13];
+  },
+}
+ };
+        let __v_13: G = __mc_out___mc_0[0];
+        let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_2.as_canonical_u64() {
+  1u64 => {
+    let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[580].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_580] = unsafe { *(result.output.as_ptr() as *const [G; OUT_580]) }; __ret } else { aiur_fn_580(__args, record, io_buffer, __cu)? } };
+    let __v_14: G = __r_arr[0];
+    break '__mc_1 [__v_14];
+  },
+  _ => {
+    let __v_14: G = G::from_u64(1);
+    break '__mc_1 [__v_14];
+  },
+}
+ };
+        let __v_14: G = __mc_out___mc_1[0];
+        let __v_15: G = (__v_11 * __v_13);
+        let __v_16: G = (__v_15 * __v_14);
+        match __v_16.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } };
-            let __v_10: G = __r_arr[0];
-            let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_671] = [__v_10, __v_11];
-            record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          2u64 => {
-            let __r_arr: [G; OUT_667] = { let __args: [G; IN_667] = [__v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[667].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_667] = unsafe { *(result.output.as_ptr() as *const [G; OUT_667]) }; __ret } else { aiur_fn_667(__args, record, io_buffer, __cu)? } };
-            let __v_10: G = __r_arr[0];
-            let __v_11: G = __r_arr[1];
-            let __r_arr: [G; OUT_664] = { let __args: [G; IN_664] = [__v_1, __v_5, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[664].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_664] = unsafe { *(result.output.as_ptr() as *const [G; OUT_664]) }; __ret } else { aiur_fn_664(__args, record, io_buffer, __cu)? } };
-            let __v_12: G = __r_arr[0];
-            let __v_13: G = __r_arr[1];
-            let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } };
-            let __v_14: G = __r_arr[0];
-            let __v_15: G = __r_arr[1];
-            let __ret: [G; OUT_671] = [__v_14, __v_15];
-            record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __v_17: G = G::from_u64(1);
+            let __ret: [G; OUT_588] = [__v_17, __v_4];
+            record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[656].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_656] = unsafe { *(result.output.as_ptr() as *const [G; OUT_656]) }; __ret } else { aiur_fn_656(__args, record, io_buffer, __cu)? } };
-            let __v_10: G = __r_arr[0];
-            let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_671] = [__v_10, __v_11];
-            record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __v_17: G = G::from_u64(1);
+            let __v_18: G = (__v_4 + __v_17);
+            let __r_arr: [G; OUT_588] = { let __args: [G; IN_588] = [__v_10, __v_1, __v_2, __v_3, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[588].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_588] = unsafe { *(result.output.as_ptr() as *const [G; OUT_588]) }; __ret } else { aiur_fn_588(__args, record, io_buffer, __cu)? } };
+            let __v_19: G = __r_arr[0];
+            let __v_20: G = __r_arr[1];
+            let __ret: [G; OUT_588] = [__v_19, __v_20];
+            record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
-      3u64 => {
-        match __v_4.as_canonical_u64() {
-          0u64 => {
-            let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } };
-            let __v_10: G = __r_arr[0];
-            let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_671] = [__v_10, __v_11];
-            record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          1u64 => {
-            let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } };
-            let __v_10: G = __r_arr[0];
-            let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_671] = [__v_10, __v_11];
-            record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          2u64 => {
-            let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } };
-            let __v_10: G = __r_arr[0];
-            let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_671] = [__v_10, __v_11];
-            record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          3u64 => {
-            let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_1, __v_5, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[670].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_670] = unsafe { *(result.output.as_ptr() as *const [G; OUT_670]) }; __ret } else { aiur_fn_670(__args, record, io_buffer, __cu)? } };
-            let __v_10: G = __r_arr[0];
-            let __v_11: G = __r_arr[1];
-            let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_2, __v_6, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[670].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_670] = unsafe { *(result.output.as_ptr() as *const [G; OUT_670]) }; __ret } else { aiur_fn_670(__args, record, io_buffer, __cu)? } };
-            let __v_12: G = __r_arr[0];
-            let __v_13: G = __r_arr[1];
-            let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } };
-            let __v_14: G = __r_arr[0];
-            let __v_15: G = __r_arr[1];
-            let __ret: [G; OUT_671] = [__v_14, __v_15];
-            record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            let __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[656].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_656] = unsafe { *(result.output.as_ptr() as *const [G; OUT_656]) }; __ret } else { aiur_fn_656(__args, record, io_buffer, __cu)? } };
-            let __v_10: G = __r_arr[0];
-            let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_671] = [__v_10, __v_11];
-            record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-        }
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
       },
-      4u64 => {
-        match __v_4.as_canonical_u64() {
-          0u64 => {
-            let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } };
-            let __v_10: G = __r_arr[0];
-            let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_671] = [__v_10, __v_11];
-            record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          1u64 => {
-            let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } };
-            let __v_10: G = __r_arr[0];
-            let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_671] = [__v_10, __v_11];
-            record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          2u64 => {
-            let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } };
-            let __v_10: G = __r_arr[0];
-            let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_671] = [__v_10, __v_11];
-            record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          3u64 => {
-            let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } };
-            let __v_10: G = __r_arr[0];
-            let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_671] = [__v_10, __v_11];
-            record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          4u64 => {
-            let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_1, __v_5, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[670].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_670] = unsafe { *(result.output.as_ptr() as *const [G; OUT_670]) }; __ret } else { aiur_fn_670(__args, record, io_buffer, __cu)? } };
-            let __v_10: G = __r_arr[0];
-            let __v_11: G = __r_arr[1];
-            let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_2, __v_6, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[670].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_670] = unsafe { *(result.output.as_ptr() as *const [G; OUT_670]) }; __ret } else { aiur_fn_670(__args, record, io_buffer, __cu)? } };
-            let __v_12: G = __r_arr[0];
-            let __v_13: G = __r_arr[1];
-            let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } };
-            let __v_14: G = __r_arr[0];
-            let __v_15: G = __r_arr[1];
-            let __ret: [G; OUT_671] = [__v_14, __v_15];
-            record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            let __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[656].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_656] = unsafe { *(result.output.as_ptr() as *const [G; OUT_656]) }; __ret } else { aiur_fn_656(__args, record, io_buffer, __cu)? } };
-            let __v_10: G = __r_arr[0];
-            let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_671] = [__v_10, __v_11];
-            record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-        }
+    }
+  })
+}
+
+const INPUT_SIZE_589: usize = 2;
+const IN_589: usize = 2;
+const OUT_589: usize = 4;
+fn aiur_fn_589(
+  inp: [G; IN_589],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_589], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; 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: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].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];
+    match __v_2.as_canonical_u64() {
+      1u64 => {
+        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 __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 = 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 __v_24: G = G::from_u64(0);
+        let __v_25: G = G::from_u64(0);
+        let __v_26: G = G::from_u64(0);
+        let __v_27: G = G::from_u64(0);
+        let __v_28: G = G::from_u64(0);
+        let __v_29: G = G::from_u64(0);
+        let __v_30: G = G::from_u64(0);
+        let __v_31: G = G::from_u64(0);
+        let __v_32: G = G::from_u64(0);
+        let __v_33: G = G::from_u64(0);
+        let __v_34: G = G::from_u64(0);
+        let __v_35: G = G::from_u64(0);
+        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 = { let __values: [G; 32] = [__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, __v_37, __v_38, __v_39]; 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_41: G = G::from_u64(0);
+        let __v_42: G = G::from_u64(1);
+        let __v_43: G = G::from_u64(1);
+        let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __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 = 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 __ret: [G; OUT_589] = [__v_40, __v_41, __v_44, __v_47];
+        record.function_queries[589].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
-      5u64 => {
-        match __v_4.as_canonical_u64() {
+      0u64 => {
+        match __v_1.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } };
-            let __v_10: G = __r_arr[0];
-            let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_671] = [__v_10, __v_11];
-            record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          1u64 => {
-            let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } };
-            let __v_10: G = __r_arr[0];
-            let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_671] = [__v_10, __v_11];
-            record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          2u64 => {
-            let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } };
-            let __v_10: G = __r_arr[0];
-            let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_671] = [__v_10, __v_11];
-            record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          3u64 => {
-            let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } };
-            let __v_10: G = __r_arr[0];
-            let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_671] = [__v_10, __v_11];
-            record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          4u64 => {
-            let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } };
-            let __v_10: G = __r_arr[0];
-            let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_671] = [__v_10, __v_11];
-            record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          5u64 => {
-            let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_1, __v_5, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[670].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_670] = unsafe { *(result.output.as_ptr() as *const [G; OUT_670]) }; __ret } else { aiur_fn_670(__args, record, io_buffer, __cu)? } };
-            let __v_10: G = __r_arr[0];
-            let __v_11: G = __r_arr[1];
-            let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_2, __v_6, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[670].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_670] = unsafe { *(result.output.as_ptr() as *const [G; OUT_670]) }; __ret } else { aiur_fn_670(__args, record, io_buffer, __cu)? } };
-            let __v_12: G = __r_arr[0];
-            let __v_13: G = __r_arr[1];
-            let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } };
-            let __v_14: G = __r_arr[0];
-            let __v_15: G = __r_arr[1];
-            let __ret: [G; OUT_671] = [__v_14, __v_15];
-            record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_589] = [__v_3, __v_4, __v_5, __v_6];
+            record.function_queries[589].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[656].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_656] = unsafe { *(result.output.as_ptr() as *const [G; OUT_656]) }; __ret } else { aiur_fn_656(__args, record, io_buffer, __cu)? } };
+            let __v_8: G = G::from_u64(1);
+            let __v_9: G = (__v_1 - __v_8);
+            let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_7, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[589].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_589] = unsafe { *(result.output.as_ptr() as *const [G; OUT_589]) }; __ret } else { aiur_fn_589(__args, record, io_buffer, __cu)? } };
             let __v_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_671] = [__v_10, __v_11];
-            record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __v_12: G = __r_arr[2];
+            let __v_13: G = __r_arr[3];
+            let __ret: [G; OUT_589] = [__v_10, __v_11, __v_12, __v_13];
+            record.function_queries[589].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
-      6u64 => {
-        match __v_4.as_canonical_u64() {
-          0u64 => {
-            let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } };
-            let __v_10: G = __r_arr[0];
-            let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_671] = [__v_10, __v_11];
-            record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_590: usize = 4;
+const IN_590: usize = 4;
+const OUT_590: usize = 1;
+fn aiur_fn_590(
+  inp: [G; IN_590],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_590], 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(0);
+        let __v_5: G = G::from_u64(1);
+        let __v_6: G = (__v_1 - __v_5);
+        let __v_7: G = (__v_6 - __v_0);
+        let __v_8: G = G::from_u64(0);
+        let __v_9: G = { let __values: [G; 4] = [__v_4, __v_7, __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_590] = [__v_9];
+        record.function_queries[590].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } else { aiur_fn_711(__args, record, io_buffer, __cu)? } };
+        let __v_4: G = __r_arr[0];
+        let __v_5: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_4.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() {
           1u64 => {
-            let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } };
-            let __v_10: G = __r_arr[0];
-            let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_671] = [__v_10, __v_11];
-            record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          2u64 => {
-            let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } };
-            let __v_10: G = __r_arr[0];
-            let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_671] = [__v_10, __v_11];
-            record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          3u64 => {
-            let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } };
-            let __v_10: G = __r_arr[0];
-            let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_671] = [__v_10, __v_11];
-            record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          4u64 => {
-            let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } };
-            let __v_10: G = __r_arr[0];
-            let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_671] = [__v_10, __v_11];
-            record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          5u64 => {
-            let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } };
-            let __v_10: G = __r_arr[0];
-            let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_671] = [__v_10, __v_11];
-            record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          6u64 => {
-            let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_1, __v_5, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[670].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_670] = unsafe { *(result.output.as_ptr() as *const [G; OUT_670]) }; __ret } else { aiur_fn_670(__args, record, io_buffer, __cu)? } };
-            let __v_10: G = __r_arr[0];
-            let __v_11: G = __r_arr[1];
-            let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_2, __v_6, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[670].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_670] = unsafe { *(result.output.as_ptr() as *const [G; OUT_670]) }; __ret } else { aiur_fn_670(__args, record, io_buffer, __cu)? } };
-            let __v_12: G = __r_arr[0];
-            let __v_13: G = __r_arr[1];
-            let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_3, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[670].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_670] = unsafe { *(result.output.as_ptr() as *const [G; OUT_670]) }; __ret } else { aiur_fn_670(__args, record, io_buffer, __cu)? } };
-            let __v_14: G = __r_arr[0];
-            let __v_15: G = __r_arr[1];
-            let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } };
-            let __v_16: G = __r_arr[0];
-            let __v_17: G = __r_arr[1];
-            let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_10, __v_11, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } };
-            let __v_18: G = __r_arr[0];
-            let __v_19: G = __r_arr[1];
-            let __ret: [G; OUT_671] = [__v_18, __v_19];
-            record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_3, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } };
+            let __v_6: G = __r_arr[0];
+            let __ret: [G; OUT_590] = [__v_6];
+            record.function_queries[590].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[656].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_656] = unsafe { *(result.output.as_ptr() as *const [G; OUT_656]) }; __ret } else { aiur_fn_656(__args, record, io_buffer, __cu)? } };
-            let __v_10: G = __r_arr[0];
-            let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_671] = [__v_10, __v_11];
-            record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __v_6: G = G::from_u64(0);
+            let __v_7: G = G::from_u64(1);
+            let __v_8: G = (__v_1 - __v_7);
+            let __v_9: G = (__v_8 - __v_0);
+            let __v_10: G = G::from_u64(0);
+            let __v_11: G = { let __values: [G; 4] = [__v_6, __v_9, __v_10, __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_590] = [__v_11];
+            record.function_queries[590].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
-      7u64 => {
-        match __v_4.as_canonical_u64() {
-          8u64 => {
-            let __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[656].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_656] = unsafe { *(result.output.as_ptr() as *const [G; OUT_656]) }; __ret } else { aiur_fn_656(__args, record, io_buffer, __cu)? } };
-            let __v_10: G = __r_arr[0];
-            let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_671] = [__v_10, __v_11];
-            record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          7u64 => {
-            let __r_arr: [G; OUT_672] = { let __args: [G; IN_672] = [__v_1, __v_2, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[672].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_672] = unsafe { *(result.output.as_ptr() as *const [G; OUT_672]) }; __ret } else { aiur_fn_672(__args, record, io_buffer, __cu)? } };
-            let __v_10: G = __r_arr[0];
-            let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } };
-            let __v_11: G = __r_arr[0];
-            let __v_12: G = __r_arr[1];
-            let __ret: [G; OUT_671] = [__v_11, __v_12];
-            record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } };
-            let __v_10: G = __r_arr[0];
-            let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_671] = [__v_10, __v_11];
-            record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-        }
+    }
+  })
+}
+
+const INPUT_SIZE_591: usize = 6;
+const IN_591: usize = 6;
+const OUT_591: usize = 1;
+fn aiur_fn_591(
+  inp: [G; IN_591],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_591], 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];
+    match __v_1.as_canonical_u64() {
+      0u64 => {
+        let __ret: [G; OUT_591] = [__v_0];
+        record.function_queries[591].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
-      8u64 => {
-        match __v_4.as_canonical_u64() {
-          8u64 => {
-            let __r_arr: [G; OUT_664] = { let __args: [G; IN_664] = [__v_1, __v_5, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[664].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_664] = unsafe { *(result.output.as_ptr() as *const [G; OUT_664]) }; __ret } else { aiur_fn_664(__args, record, io_buffer, __cu)? } };
+      _ => {
+        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_6: G = __loaded[0];
+        let __v_7: G = __loaded[1];
+        let __v_8: G = __loaded[2];
+        let __v_9: G = __loaded[3];
+        match __v_6.as_canonical_u64() {
+          5u64 => {
+            let __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = [__v_5, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[590].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_590] = unsafe { *(result.output.as_ptr() as *const [G; OUT_590]) }; __ret } else { aiur_fn_590(__args, record, io_buffer, __cu)? } };
             let __v_10: G = __r_arr[0];
-            let __v_11: G = __r_arr[1];
-            let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = unsafe { *(result.output.as_ptr() as *const [G; OUT_654]) }; __ret } else { aiur_fn_654(__args, record, io_buffer, __cu)? } };
+            let __v_11: G = G::from_u64(0);
+            let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_8, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[331].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_331] = unsafe { *(result.output.as_ptr() as *const [G; OUT_331]) }; __ret } else { aiur_fn_331(__args, record, io_buffer, __cu)? } };
             let __v_12: G = __r_arr[0];
-            let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } };
-            let __v_13: G = __r_arr[0];
-            let __v_14: G = __r_arr[1];
-            let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_3, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[670].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_670] = unsafe { *(result.output.as_ptr() as *const [G; OUT_670]) }; __ret } else { aiur_fn_670(__args, record, io_buffer, __cu)? } };
-            let __v_15: G = __r_arr[0];
-            let __v_16: G = __r_arr[1];
-            let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } };
+            let __v_13: G = G::from_u64(1);
+            let __v_14: G = (__v_1 - __v_13);
+            let __v_15: G = G::from_u64(1);
+            let __v_16: G = (__v_5 + __v_15);
+            let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_12, __v_14, __v_2, __v_3, __v_4, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[591].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_591] = unsafe { *(result.output.as_ptr() as *const [G; OUT_591]) }; __ret } else { aiur_fn_591(__args, record, io_buffer, __cu)? } };
             let __v_17: G = __r_arr[0];
-            let __v_18: G = __r_arr[1];
-            let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_10, __v_11, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } };
-            let __v_19: G = __r_arr[0];
-            let __v_20: G = __r_arr[1];
-            let __ret: [G; OUT_671] = [__v_19, __v_20];
-            record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_591] = [__v_17];
+            record.function_queries[591].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } };
-            let __v_10: G = __r_arr[0];
-            let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_671] = [__v_10, __v_11];
-            record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
+            return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64()));
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64()));
-      },
     }
   })
 }
 
-const INPUT_SIZE_672: usize = 4;
-const IN_672: usize = 4;
-const OUT_672: usize = 1;
-fn aiur_fn_672(
-  inp: [G; IN_672],
+const INPUT_SIZE_592: usize = 2;
+const IN_592: usize = 2;
+const OUT_592: usize = 1;
+fn aiur_fn_592(
+  inp: [G; IN_592],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_672], ExecError> {
+) -> Result<[G; OUT_592], 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_0.as_canonical_u64() {
+    match __v_1.as_canonical_u64() {
       0u64 => {
-        match __v_2.as_canonical_u64() {
-          0u64 => {
-            let __r_arr: [G; OUT_673] = { let __args: [G; IN_673] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[673].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_673] = unsafe { *(result.output.as_ptr() as *const [G; OUT_673]) }; __ret } else { aiur_fn_673(__args, record, io_buffer, __cu)? } };
-            let __v_4: G = __r_arr[0];
-            let __ret: [G; OUT_672] = [__v_4];
-            record.function_queries[672].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          1u64 => {
-            let __v_4: G = G::from_u64(0);
-            let __ret: [G; OUT_672] = [__v_4];
-            record.function_queries[672].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_2.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_592] = [__v_4];
+        record.function_queries[592].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
-      1u64 => {
+      _ => {
+        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() {
-          0u64 => {
-            let __v_4: G = G::from_u64(2);
-            let __ret: [G; OUT_672] = [__v_4];
-            record.function_queries[672].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          1u64 => {
-            let __r_arr: [G; OUT_676] = { let __args: [G; IN_676] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[676].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_676] = unsafe { *(result.output.as_ptr() as *const [G; OUT_676]) }; __ret } else { aiur_fn_676(__args, record, io_buffer, __cu)? } };
-            let __v_4: G = __r_arr[0];
-            let __ret: [G; OUT_672] = [__v_4];
-            record.function_queries[672].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+          5u64 => {
+            let __v_6: G = G::from_u64(0);
+            let __v_7: G = G::from_u64(1);
+            let __v_8: G = (__v_1 - __v_7);
+            let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } };
+            let __v_9: G = __r_arr[0];
+            let __v_10: G = { let __values: [G; 3] = [__v_6, __v_3, __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 __ret: [G; OUT_592] = [__v_10];
+            record.function_queries[592].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -56616,127 +49236,348 @@ fn aiur_fn_672(
           },
         }
       },
+    }
+  })
+}
+
+const INPUT_SIZE_593: usize = 4;
+const IN_593: usize = 4;
+const OUT_593: usize = 1;
+fn aiur_fn_593(
+  inp: [G; IN_593],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_593], 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_1 - __v_3);
+    match __v_4.as_canonical_u64() {
+      0u64 => {
+        let __ret: [G; OUT_593] = [__v_0];
+        record.function_queries[593].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64()));
+        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 __v_8: G = (__v_7 - __v_3);
+        let __v_9: G = (__v_8 + __v_2);
+        let __v_10: G = G::from_u64(0);
+        let __v_11: G = { let __values: [G; 4] = [__v_5, __v_9, __v_10, __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 __v_12: G = G::from_u64(3);
+        let __v_13: G = G::from_u64(0);
+        let __v_14: G = { let __values: [G; 4] = [__v_12, __v_0, __v_11, __v_13]; 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_15: G = G::from_u64(1);
+        let __v_16: G = (__v_3 + __v_15);
+        let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_14, __v_1, __v_2, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } };
+        let __v_17: G = __r_arr[0];
+        let __ret: [G; OUT_593] = [__v_17];
+        record.function_queries[593].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_673: usize = 2;
-const IN_673: usize = 2;
-const OUT_673: usize = 1;
-fn aiur_fn_673(
-  inp: [G; IN_673],
+const INPUT_SIZE_594: usize = 3;
+const IN_594: usize = 3;
+const OUT_594: usize = 1;
+fn aiur_fn_594(
+  inp: [G; IN_594],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_673], ExecError> {
+) -> Result<[G; OUT_594], 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_309] = { let __args: [G; IN_309] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } };
-    let __v_2: G = __r_arr[0];
-    let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } };
-    let __v_3: G = __r_arr[0];
-    let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[780].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_780] = unsafe { *(result.output.as_ptr() as *const [G; OUT_780]) }; __ret } else { aiur_fn_780(__args, record, io_buffer, __cu)? } };
-    let __v_4: G = __r_arr[0];
-    let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[780].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_780] = unsafe { *(result.output.as_ptr() as *const [G; OUT_780]) }; __ret } else { aiur_fn_780(__args, record, io_buffer, __cu)? } };
-    let __v_5: G = __r_arr[0];
-    let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = unsafe { *(result.output.as_ptr() as *const [G; OUT_654]) }; __ret } else { aiur_fn_654(__args, record, io_buffer, __cu)? } };
-    let __v_6: G = __r_arr[0];
-    match __v_6.as_canonical_u64() {
+    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_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_3: G = __loaded[0];
+    let __v_4: G = __loaded[1];
+    let __v_5: G = __loaded[2];
+    match __v_3.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[674].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_674] = unsafe { *(result.output.as_ptr() as *const [G; OUT_674]) }; __ret } else { aiur_fn_674(__args, record, io_buffer, __cu)? } };
+        let __ret: [G; OUT_594] = [__v_0];
+        record.function_queries[594].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __v_6: G = G::from_u64(0);
+        let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_4, __v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[325].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_325] = unsafe { *(result.output.as_ptr() as *const [G; OUT_325]) }; __ret } else { aiur_fn_325(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_673] = [__v_7];
-        record.function_queries[673].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __v_8: G = G::from_u64(3);
+        let __v_9: G = G::from_u64(0);
+        let __v_10: G = { let __values: [G; 4] = [__v_8, __v_0, __v_7, __v_9]; 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_594] = { let __args: [G; IN_594] = [__v_10, __v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[594].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_594] = unsafe { *(result.output.as_ptr() as *const [G; OUT_594]) }; __ret } else { aiur_fn_594(__args, record, io_buffer, __cu)? } };
+        let __v_11: G = __r_arr[0];
+        let __ret: [G; OUT_594] = [__v_11];
+        record.function_queries[594].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __ret: [G; OUT_673] = [__v_6];
-        record.function_queries[673].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_595: usize = 5;
+const IN_595: usize = 5;
+const OUT_595: usize = 1;
+fn aiur_fn_595(
+  inp: [G; IN_595],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_595], 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(0);
+        let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_0, __v_1, __v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } };
+        let __v_6: G = __r_arr[0];
+        let __ret: [G; OUT_595] = [__v_6];
+        record.function_queries[595].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = [__v_0, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[594].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_594] = unsafe { *(result.output.as_ptr() as *const [G; OUT_594]) }; __ret } else { aiur_fn_594(__args, record, io_buffer, __cu)? } };
+        let __v_5: G = __r_arr[0];
+        let __ret: [G; OUT_595] = [__v_5];
+        record.function_queries[595].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_674: usize = 2;
-const IN_674: usize = 2;
-const OUT_674: usize = 1;
-fn aiur_fn_674(
-  inp: [G; IN_674],
+const INPUT_SIZE_596: usize = 3;
+const IN_596: usize = 3;
+const OUT_596: usize = 1;
+fn aiur_fn_596(
+  inp: [G; IN_596],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_674], ExecError> {
+) -> Result<[G; OUT_596], 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 = inp[2];
+    let __v_3: G = (__v_1 - __v_2);
+    match __v_3.as_canonical_u64() {
+      0u64 => {
+        let __ret: [G; OUT_596] = [__v_0];
+        record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __v_4: G = G::from_u64(0);
+        let __v_5: G = G::from_u64(1);
+        let __v_6: G = (__v_1 - __v_5);
+        let __v_7: G = (__v_6 - __v_2);
+        let __v_8: G = G::from_u64(0);
+        let __v_9: G = { let __values: [G; 4] = [__v_4, __v_7, __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 __v_10: G = G::from_u64(3);
+        let __v_11: G = G::from_u64(0);
+        let __v_12: G = { let __values: [G; 4] = [__v_10, __v_0, __v_9, __v_11]; 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_13: G = G::from_u64(1);
+        let __v_14: G = (__v_2 + __v_13);
+        let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_12, __v_1, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } else { aiur_fn_596(__args, record, io_buffer, __cu)? } };
+        let __v_15: G = __r_arr[0];
+        let __ret: [G; OUT_596] = [__v_15];
+        record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_597: usize = 2;
+const IN_597: usize = 2;
+const OUT_597: usize = 1;
+fn aiur_fn_597(
+  inp: [G; IN_597],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_597], 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];
-    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 __v_12: G = G::from_u64(1);
-        let __ret: [G; OUT_674] = [__v_12];
-        record.function_queries[674].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_597] = [__v_0];
+        record.function_queries[597].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_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: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
-        let __v_12: G = __loaded[0];
-        let __v_13: G = __loaded[1];
-        let __v_14: G = __loaded[2];
-        let __v_15: G = __loaded[3];
-        let __v_16: G = __loaded[4];
-        let __v_17: G = __loaded[5];
-        let __v_18: G = __loaded[6];
-        let __v_19: G = __loaded[7];
-        let __v_20: G = __loaded[8];
-        let __v_21: G = __loaded[9];
-        match __v_12.as_canonical_u64() {
-          0u64 => {
-            let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[674].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_674] = unsafe { *(result.output.as_ptr() as *const [G; OUT_674]) }; __ret } else { aiur_fn_674(__args, record, io_buffer, __cu)? } };
-            let __v_22: G = __r_arr[0];
-            let __r_arr: [G; OUT_675] = { let __args: [G; IN_675] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } else { aiur_fn_675(__args, record, io_buffer, __cu)? } };
-            let __v_23: G = __r_arr[0];
-            let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[655].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_655] = unsafe { *(result.output.as_ptr() as *const [G; OUT_655]) }; __ret } else { aiur_fn_655(__args, record, io_buffer, __cu)? } };
-            let __v_24: G = __r_arr[0];
-            let __ret: [G; OUT_674] = [__v_24];
-            record.function_queries[674].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __v_5: G = G::from_u64(5);
+        let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[597].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_597] = unsafe { *(result.output.as_ptr() as *const [G; OUT_597]) }; __ret } else { aiur_fn_597(__args, record, io_buffer, __cu)? } };
+        let __v_6: G = __r_arr[0];
+        let __v_7: G = G::from_u64(0);
+        let __v_8: G = { let __values: [G; 4] = [__v_5, __v_3, __v_6, __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_597] = [__v_8];
+        record.function_queries[597].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_598: usize = 2;
+const IN_598: usize = 2;
+const OUT_598: usize = 2;
+fn aiur_fn_598(
+  inp: [G; IN_598],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_598], 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_598] = [__v_4, __v_0];
+        record.function_queries[598].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        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() {
+          5u64 => {
+            let __v_6: G = G::from_u64(1);
+            let __v_7: G = (__v_1 - __v_6);
+            let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = unsafe { *(result.output.as_ptr() as *const [G; OUT_598]) }; __ret } else { aiur_fn_598(__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_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_598] = [__v_11, __v_9];
+            record.function_queries[598].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64()));
+            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 __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = unsafe { *(result.output.as_ptr() as *const [G; OUT_377]) }; __ret } else { aiur_fn_377(__args, record, io_buffer, __cu)? } };
+            let __v_9: 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_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: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].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];
+            match __v_10.as_canonical_u64() {
+              5u64 => {
+                let __v_14: G = G::from_u64(1);
+                let __v_15: G = (__v_1 - __v_14);
+                let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_12, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = unsafe { *(result.output.as_ptr() as *const [G; OUT_598]) }; __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } };
+                let __v_16: G = __r_arr[0];
+                let __v_17: G = __r_arr[1];
+                let __v_18: G = G::from_u64(0);
+                let __v_19: G = { let __values: [G; 3] = [__v_18, __v_11, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_598] = [__v_19, __v_17];
+                record.function_queries[598].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                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 __ret: [G; OUT_598] = [__v_16, __v_0];
+                record.function_queries[598].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+            }
           },
         }
       },
+    }
+  })
+}
+
+const INPUT_SIZE_599: usize = 3;
+const IN_599: usize = 3;
+const OUT_599: usize = 1;
+fn aiur_fn_599(
+  inp: [G; IN_599],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_599], 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_599] = [__v_8];
+        record.function_queries[599].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __v_6: G = G::from_u64(0);
+        let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[325].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_325] = unsafe { *(result.output.as_ptr() as *const [G; OUT_325]) }; __ret } else { aiur_fn_325(__args, record, io_buffer, __cu)? } };
+        let __v_7: G = __r_arr[0];
+        let __v_8: G = G::from_u64(1);
+        let __v_9: G = (__v_2 + __v_8);
+        let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_5, __v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } };
+        let __v_10: G = __r_arr[0];
+        let __v_11: G = { let __values: [G; 3] = [__v_6, __v_7, __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 __ret: [G; OUT_599] = [__v_11];
+        record.function_queries[599].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_675: usize = 16;
-const IN_675: usize = 16;
-const OUT_675: usize = 1;
-fn aiur_fn_675(
-  inp: [G; IN_675],
+const INPUT_SIZE_600: usize = 6;
+const IN_600: usize = 6;
+const OUT_600: usize = 1;
+fn aiur_fn_600(
+  inp: [G; IN_600],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_675], ExecError> {
+) -> Result<[G; OUT_600], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -56744,265 +49585,225 @@ fn aiur_fn_675(
     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 __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_7, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = unsafe { *(result.output.as_ptr() as *const [G; OUT_654]) }; __ret } else { aiur_fn_654(__args, record, io_buffer, __cu)? } };
-    let __v_16: G = __r_arr[0];
-    let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_6, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = unsafe { *(result.output.as_ptr() as *const [G; OUT_654]) }; __ret } else { aiur_fn_654(__args, record, io_buffer, __cu)? } };
-    let __v_17: G = __r_arr[0];
-    let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_5, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = unsafe { *(result.output.as_ptr() as *const [G; OUT_654]) }; __ret } else { aiur_fn_654(__args, record, io_buffer, __cu)? } };
-    let __v_18: G = __r_arr[0];
-    let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_4, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = unsafe { *(result.output.as_ptr() as *const [G; OUT_654]) }; __ret } else { aiur_fn_654(__args, record, io_buffer, __cu)? } };
-    let __v_19: G = __r_arr[0];
-    let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_3, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = unsafe { *(result.output.as_ptr() as *const [G; OUT_654]) }; __ret } else { aiur_fn_654(__args, record, io_buffer, __cu)? } };
-    let __v_20: G = __r_arr[0];
-    let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_2, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = unsafe { *(result.output.as_ptr() as *const [G; OUT_654]) }; __ret } else { aiur_fn_654(__args, record, io_buffer, __cu)? } };
-    let __v_21: G = __r_arr[0];
-    let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = unsafe { *(result.output.as_ptr() as *const [G; OUT_654]) }; __ret } else { aiur_fn_654(__args, record, io_buffer, __cu)? } };
-    let __v_22: G = __r_arr[0];
-    let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = unsafe { *(result.output.as_ptr() as *const [G; OUT_654]) }; __ret } else { aiur_fn_654(__args, record, io_buffer, __cu)? } };
-    let __v_23: G = __r_arr[0];
-    let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[655].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_655] = unsafe { *(result.output.as_ptr() as *const [G; OUT_655]) }; __ret } else { aiur_fn_655(__args, record, io_buffer, __cu)? } };
-    let __v_24: G = __r_arr[0];
-    let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_21, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[655].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_655] = unsafe { *(result.output.as_ptr() as *const [G; OUT_655]) }; __ret } else { aiur_fn_655(__args, record, io_buffer, __cu)? } };
-    let __v_25: G = __r_arr[0];
-    let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_20, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[655].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_655] = unsafe { *(result.output.as_ptr() as *const [G; OUT_655]) }; __ret } else { aiur_fn_655(__args, record, io_buffer, __cu)? } };
-    let __v_26: G = __r_arr[0];
-    let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_19, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[655].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_655] = unsafe { *(result.output.as_ptr() as *const [G; OUT_655]) }; __ret } else { aiur_fn_655(__args, record, io_buffer, __cu)? } };
-    let __v_27: G = __r_arr[0];
-    let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_18, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[655].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_655] = unsafe { *(result.output.as_ptr() as *const [G; OUT_655]) }; __ret } else { aiur_fn_655(__args, record, io_buffer, __cu)? } };
-    let __v_28: G = __r_arr[0];
-    let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_17, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[655].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_655] = unsafe { *(result.output.as_ptr() as *const [G; OUT_655]) }; __ret } else { aiur_fn_655(__args, record, io_buffer, __cu)? } };
-    let __v_29: G = __r_arr[0];
-    let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_16, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[655].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_655] = unsafe { *(result.output.as_ptr() as *const [G; OUT_655]) }; __ret } else { aiur_fn_655(__args, record, io_buffer, __cu)? } };
-    let __v_30: G = __r_arr[0];
-    let __ret: [G; OUT_675] = [__v_30];
-    record.function_queries[675].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
+    match __v_4.as_canonical_u64() {
+      1u64 => {
+        let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = [__v_0, __v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[594].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_594] = unsafe { *(result.output.as_ptr() as *const [G; OUT_594]) }; __ret } else { aiur_fn_594(__args, record, io_buffer, __cu)? } };
+        let __v_6: G = __r_arr[0];
+        let __ret: [G; OUT_600] = [__v_6];
+        record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __v_6: G = G::from_u64(0);
+        let __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_0, __v_1, __v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[604].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_604] = unsafe { *(result.output.as_ptr() as *const [G; OUT_604]) }; __ret } else { aiur_fn_604(__args, record, io_buffer, __cu)? } };
+        let __v_7: G = __r_arr[0];
+        let __ret: [G; OUT_600] = [__v_7];
+        record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+    }
   })
 }
 
-const INPUT_SIZE_676: usize = 2;
-const IN_676: usize = 2;
-const OUT_676: usize = 1;
-fn aiur_fn_676(
-  inp: [G; IN_676],
+const INPUT_SIZE_601: usize = 3;
+const IN_601: usize = 3;
+const OUT_601: usize = 1;
+fn aiur_fn_601(
+  inp: [G; IN_601],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_676], ExecError> {
+) -> Result<[G; OUT_601], 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 __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_5: G = __loaded[0];
-        let __v_6: G = __loaded[1];
-        let __v_7: G = __loaded[2];
-        match __v_5.as_canonical_u64() {
-          1u64 => {
-            let __v_8: G = G::from_u64(1);
-            let __ret: [G; OUT_676] = [__v_8];
-            record.function_queries[676].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_676] = [__v_8];
-            record.function_queries[676].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-        }
-      },
+    let __v_2: G = inp[2];
+    let __v_3: G = (__v_1 - __v_2);
+    match __v_3.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_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_5: G = __loaded[0];
-        let __v_6: G = __loaded[1];
-        let __v_7: G = __loaded[2];
-        match __v_5.as_canonical_u64() {
-          1u64 => {
-            let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_676] = [__v_8];
-            record.function_queries[676].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          0u64 => {
-            let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = unsafe { *(result.output.as_ptr() as *const [G; OUT_654]) }; __ret } else { aiur_fn_654(__args, record, io_buffer, __cu)? } };
-            let __v_8: G = __r_arr[0];
-            let __r_arr: [G; OUT_676] = { let __args: [G; IN_676] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[676].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_676] = unsafe { *(result.output.as_ptr() as *const [G; OUT_676]) }; __ret } else { aiur_fn_676(__args, record, io_buffer, __cu)? } };
-            let __v_9: G = __r_arr[0];
-            let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[655].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_655] = unsafe { *(result.output.as_ptr() as *const [G; OUT_655]) }; __ret } else { aiur_fn_655(__args, record, io_buffer, __cu)? } };
-            let __v_10: G = __r_arr[0];
-            let __ret: [G; OUT_676] = [__v_10];
-            record.function_queries[676].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
-          },
-        }
+        let __ret: [G; OUT_601] = [__v_0];
+        record.function_queries[601].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+        let __v_4: G = G::from_u64(0);
+        let __v_5: G = (__v_1 - __v_2);
+        let __v_6: G = G::from_u64(0);
+        let __v_7: G = { let __values: [G; 4] = [__v_4, __v_5, __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 __v_8: G = G::from_u64(3);
+        let __v_9: G = G::from_u64(0);
+        let __v_10: G = { let __values: [G; 4] = [__v_8, __v_0, __v_7, __v_9]; 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_11: G = G::from_u64(1);
+        let __v_12: G = (__v_2 + __v_11);
+        let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = [__v_10, __v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[601].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_601] = unsafe { *(result.output.as_ptr() as *const [G; OUT_601]) }; __ret } else { aiur_fn_601(__args, record, io_buffer, __cu)? } };
+        let __v_13: G = __r_arr[0];
+        let __ret: [G; OUT_601] = [__v_13];
+        record.function_queries[601].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_677: usize = 8;
-const IN_677: usize = 8;
-const OUT_677: usize = 2;
-fn aiur_fn_677(
-  inp: [G; IN_677],
+const INPUT_SIZE_602: usize = 9;
+const IN_602: usize = 9;
+const OUT_602: usize = 1;
+fn aiur_fn_602(
+  inp: [G; IN_602],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_602], 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_307] = { let __args: [G; IN_307] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } else { aiur_fn_307(__args, record, io_buffer, __cu)? } };
+    let __v_9: G = __r_arr[0];
+    let __v_10: G = G::from_u64(0);
+    let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_9, __v_2, __v_6, __v_7, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[591].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_591] = unsafe { *(result.output.as_ptr() as *const [G; OUT_591]) }; __ret } else { aiur_fn_591(__args, record, io_buffer, __cu)? } };
+    let __v_11: G = __r_arr[0];
+    let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } };
+    let __v_12: G = __r_arr[0];
+    let __v_13: G = G::from_u64(2);
+    let __v_14: G = G::from_u64(0);
+    let __v_15: G = { let __values: [G; 4] = [__v_13, __v_0, __v_4, __v_14]; 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_595] = { let __args: [G; IN_595] = [__v_15, __v_6, __v_3, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[595].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_595] = unsafe { *(result.output.as_ptr() as *const [G; OUT_595]) }; __ret } else { aiur_fn_595(__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_596] = { let __args: [G; IN_596] = [__v_16, __v_3, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } else { aiur_fn_596(__args, record, io_buffer, __cu)? } };
+    let __v_18: G = __r_arr[0];
+    let __v_19: G = G::from_u64(1);
+    let __v_20: G = G::from_u64(0);
+    let __v_21: G = { let __values: [G; 4] = [__v_19, __v_5, __v_20, __v_20]; 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_22: G = G::from_u64(5);
+    let __v_23: G = G::from_u64(0);
+    let __v_24: G = { let __values: [G; 4] = [__v_22, __v_18, __v_21, __v_23]; 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_597] = { let __args: [G; IN_597] = [__v_24, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[597].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_597] = unsafe { *(result.output.as_ptr() as *const [G; OUT_597]) }; __ret } else { aiur_fn_597(__args, record, io_buffer, __cu)? } };
+    let __v_25: G = __r_arr[0];
+    let __ret: [G; OUT_602] = [__v_25];
+    record.function_queries[602].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_603: usize = 3;
+const IN_603: usize = 3;
+const OUT_603: usize = 1;
+fn aiur_fn_603(
+  inp: [G; IN_603],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_603], 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 = G::from_u64(0);
+    let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[638].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_638] = unsafe { *(result.output.as_ptr() as *const [G; OUT_638]) }; __ret } else { aiur_fn_638(__args, record, io_buffer, __cu)? } };
+    let __v_4: G = __r_arr[0];
+    let __ret: [G; OUT_603] = [__v_4];
+    record.function_queries[603].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_604: usize = 4;
+const IN_604: usize = 4;
+const OUT_604: usize = 1;
+fn aiur_fn_604(
+  inp: [G; IN_604],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_677], ExecError> {
+) -> Result<[G; OUT_604], 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];
-    match __v_0.as_canonical_u64() {
+    let __v_4: G = (__v_1 - __v_3);
+    match __v_4.as_canonical_u64() {
+      0u64 => {
+        let __ret: [G; OUT_604] = [__v_0];
+        record.function_queries[604].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
       _ => {
-        match __v_3.as_canonical_u64() {
-          _ => {
-            let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = unsafe { *(result.output.as_ptr() as *const [G; OUT_654]) }; __ret } else { aiur_fn_654(__args, record, io_buffer, __cu)? } };
-            let __v_8: G = __r_arr[0];
-            let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } };
-            let __v_9: G = __r_arr[0];
-            let __v_10: G = __r_arr[1];
-            let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_2, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[670].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_670] = unsafe { *(result.output.as_ptr() as *const [G; OUT_670]) }; __ret } else { aiur_fn_670(__args, record, io_buffer, __cu)? } };
-            let __v_11: G = __r_arr[0];
-            let __v_12: G = __r_arr[1];
-            let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } };
-            let __v_13: G = __r_arr[0];
-            let __v_14: G = __r_arr[1];
-            let __ret: [G; OUT_677] = [__v_13, __v_14];
-            record.function_queries[677].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-        }
+        let __v_5: G = G::from_u64(0);
+        let __v_6: G = (__v_2 - __v_3);
+        let __v_7: G = G::from_u64(0);
+        let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __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 __v_9: G = G::from_u64(3);
+        let __v_10: G = G::from_u64(0);
+        let __v_11: G = { let __values: [G; 4] = [__v_9, __v_0, __v_8, __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 __v_12: G = G::from_u64(1);
+        let __v_13: G = (__v_3 + __v_12);
+        let __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_11, __v_1, __v_2, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[604].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_604] = unsafe { *(result.output.as_ptr() as *const [G; OUT_604]) }; __ret } else { aiur_fn_604(__args, record, io_buffer, __cu)? } };
+        let __v_14: G = __r_arr[0];
+        let __ret: [G; OUT_604] = [__v_14];
+        record.function_queries[604].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_678: usize = 4;
-const IN_678: usize = 4;
-const OUT_678: usize = 2;
-fn aiur_fn_678(
-  inp: [G; IN_678],
+const INPUT_SIZE_605: usize = 2;
+const IN_605: usize = 2;
+const OUT_605: usize = 1;
+fn aiur_fn_605(
+  inp: [G; IN_605],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_678], ExecError> {
+) -> Result<[G; OUT_605], 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; 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 };
-    let __v_4: G = __loaded[0];
-    let __v_5: G = __loaded[1];
-    let __v_6: G = __loaded[2];
-    let __v_7: G = __loaded[3];
-    let __v_8: G = __loaded[4];
-    match __v_4.as_canonical_u64() {
+    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 __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; 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: 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 __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[657].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_657] = unsafe { *(result.output.as_ptr() as *const [G; OUT_657]) }; __ret } else { aiur_fn_657(__args, record, io_buffer, __cu)? } };
-            let __v_14: G = __r_arr[0];
-            let __v_15: G = __r_arr[1];
-            let __ret: [G; OUT_678] = [__v_14, __v_15];
-            record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            let __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[656].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_656] = unsafe { *(result.output.as_ptr() as *const [G; OUT_656]) }; __ret } else { aiur_fn_656(__args, record, io_buffer, __cu)? } };
-            let __v_14: G = __r_arr[0];
-            let __v_15: G = __r_arr[1];
-            let __ret: [G; OUT_678] = [__v_14, __v_15];
-            record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-        }
+        let __ret: [G; OUT_605] = [__v_0];
+        record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
       0u64 => {
-        let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; 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: 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 __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } };
-            let __v_14: G = __r_arr[0];
-            let __v_15: G = __r_arr[1];
-            let __ret: [G; OUT_678] = [__v_14, __v_15];
-            record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          0u64 => {
-            let __r_arr: [G; OUT_677] = { let __args: [G; IN_677] = [__v_5, __v_6, __v_7, __v_10, __v_11, __v_12, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[677].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_677] = unsafe { *(result.output.as_ptr() as *const [G; OUT_677]) }; __ret } else { aiur_fn_677(__args, record, io_buffer, __cu)? } };
-            let __v_14: G = __r_arr[0];
-            let __v_15: G = __r_arr[1];
-            let __r_arr: [G; OUT_678] = { let __args: [G; IN_678] = [__v_8, __v_13, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[678].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_678] = unsafe { *(result.output.as_ptr() as *const [G; OUT_678]) }; __ret } else { aiur_fn_678(__args, record, io_buffer, __cu)? } };
-            let __v_16: G = __r_arr[0];
-            let __v_17: G = __r_arr[1];
-            let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } };
-            let __v_18: G = __r_arr[0];
-            let __v_19: G = __r_arr[1];
-            let __ret: [G; OUT_678] = [__v_18, __v_19];
-            record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64()));
-          },
-        }
+        let __v_5: G = G::from_u64(4);
+        let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[605].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_605] = unsafe { *(result.output.as_ptr() as *const [G; OUT_605]) }; __ret } else { aiur_fn_605(__args, record, io_buffer, __cu)? } };
+        let __v_6: G = __r_arr[0];
+        let __v_7: G = G::from_u64(0);
+        let __v_8: G = { let __values: [G; 4] = [__v_5, __v_3, __v_6, __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_605] = [__v_8];
+        record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_679: usize = 11;
-const IN_679: usize = 11;
-const OUT_679: usize = 1;
-fn aiur_fn_679(
-  inp: [G; IN_679],
+const INPUT_SIZE_606: usize = 9;
+const IN_606: usize = 9;
+const OUT_606: usize = 1;
+fn aiur_fn_606(
+  inp: [G; IN_606],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_679], ExecError> {
+) -> Result<[G; OUT_606], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -57013,73 +49814,55 @@ fn aiur_fn_679(
     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];
-    match __v_0.as_canonical_u64() {
-      1u64 => {
-        let __v_11: G = G::from_u64(0);
-        let __ret: [G; OUT_679] = [__v_11];
-        record.function_queries[679].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      2u64 => {
-        let __v_11: G = G::from_u64(0);
-        let __ret: [G; OUT_679] = [__v_11];
-        record.function_queries[679].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      3u64 => {
-        let __v_11: G = G::from_u64(0);
-        let __ret: [G; OUT_679] = [__v_11];
-        record.function_queries[679].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
+    let __v_9: G = G::from_u64(0);
+    let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[589].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_589] = unsafe { *(result.output.as_ptr() as *const [G; OUT_589]) }; __ret } else { aiur_fn_589(__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 __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[258].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_258] = unsafe { *(result.output.as_ptr() as *const [G; OUT_258]) }; __ret } else { aiur_fn_258(__args, record, io_buffer, __cu)? } };
+    let __v_14: G = __r_arr[0];
+    let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+    let __v_15: G = __loaded[0];
+    let __v_16: G = __loaded[1];
+    let __v_17: G = __loaded[2];
+    let __v_18: G = __loaded[3];
+    let __v_19: G = __loaded[4];
+    let __v_20: G = __loaded[5];
+    let __v_21: G = __loaded[6];
+    let __v_22: G = __loaded[7];
+    let __v_23: G = __loaded[8];
+    let __v_24: G = __loaded[9];
+    let __v_25: G = __loaded[10];
+    let __v_26: G = __loaded[11];
+    match __v_15.as_canonical_u64() {
       5u64 => {
-        let __v_11: G = G::from_u64(1);
-        let __ret: [G; OUT_679] = [__v_11];
-        record.function_queries[679].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      7u64 => {
-        let __v_11: G = G::from_u64(2);
-        let __ret: [G; OUT_679] = [__v_11];
-        record.function_queries[679].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      6u64 => {
-        let __v_11: G = G::from_u64(3);
-        let __ret: [G; OUT_679] = [__v_11];
-        record.function_queries[679].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __v_11: G = G::from_u64(4);
-        let __ret: [G; OUT_679] = [__v_11];
-        record.function_queries[679].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      4u64 => {
-        let __v_11: G = G::from_u64(5);
-        let __ret: [G; OUT_679] = [__v_11];
-        record.function_queries[679].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_17, __v_16, __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[607].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_607] = unsafe { *(result.output.as_ptr() as *const [G; OUT_607]) }; __ret } else { aiur_fn_607(__args, record, io_buffer, __cu)? } };
+        let __v_27: G = __r_arr[0];
+        let __ret: [G; OUT_606] = [__v_27];
+        record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64()));
+        let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_0, __v_1, __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[607].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_607] = unsafe { *(result.output.as_ptr() as *const [G; OUT_607]) }; __ret } else { aiur_fn_607(__args, record, io_buffer, __cu)? } };
+        let __v_27: G = __r_arr[0];
+        let __ret: [G; OUT_606] = [__v_27];
+        record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_680: usize = 25;
-const IN_680: usize = 25;
-const OUT_680: usize = 2;
-fn aiur_fn_680(
-  inp: [G; IN_680],
+const INPUT_SIZE_607: usize = 11;
+const IN_607: usize = 11;
+const OUT_607: usize = 1;
+fn aiur_fn_607(
+  inp: [G; IN_607],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_680], ExecError> {
+) -> Result<[G; OUT_607], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -57092,56 +49875,93 @@ fn aiur_fn_680(
     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 __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[679].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_679] = unsafe { *(result.output.as_ptr() as *const [G; OUT_679]) }; __ret } else { aiur_fn_679(__args, record, io_buffer, __cu)? } };
-    let __v_25: G = __r_arr[0];
-    let __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[679].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_679] = unsafe { *(result.output.as_ptr() as *const [G; OUT_679]) }; __ret } else { aiur_fn_679(__args, record, io_buffer, __cu)? } };
-    let __v_26: G = __r_arr[0];
-    let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = unsafe { *(result.output.as_ptr() as *const [G; OUT_654]) }; __ret } else { aiur_fn_654(__args, record, io_buffer, __cu)? } };
-    let __v_27: G = __r_arr[0];
-    match __v_27.as_canonical_u64() {
-      1u64 => {
-        let __r_arr: [G; OUT_681] = { let __args: [G; IN_681] = [__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]; let __cu = unconstrained; if let Some(result) = record.function_queries[681].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_681] = unsafe { *(result.output.as_ptr() as *const [G; OUT_681]) }; __ret } else { aiur_fn_681(__args, record, io_buffer, __cu)? } };
-        let __v_28: G = __r_arr[0];
-        let __v_29: G = __r_arr[1];
-        let __ret: [G; OUT_680] = [__v_28, __v_29];
-        record.function_queries[680].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } };
-        let __v_28: G = __r_arr[0];
-        let __v_29: G = __r_arr[1];
-        let __ret: [G; OUT_680] = [__v_28, __v_29];
-        record.function_queries[680].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-    }
+    let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[726].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_726] = unsafe { *(result.output.as_ptr() as *const [G; OUT_726]) }; __ret } else { aiur_fn_726(__args, record, io_buffer, __cu)? } };
+    let __v_11: G = __r_arr[0];
+    let __v_12: G = G::from_u64(0);
+    let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_7, __v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } else { aiur_fn_574(__args, record, io_buffer, __cu)? } };
+    let __v_13: G = __r_arr[0];
+    let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } else { aiur_fn_307(__args, record, io_buffer, __cu)? } };
+    let __v_14: G = __r_arr[0];
+    let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_14, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = unsafe { *(result.output.as_ptr() as *const [G; OUT_598]) }; __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } };
+    let __v_15: G = __r_arr[0];
+    let __v_16: G = __r_arr[1];
+    let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_8, __v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[603].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_603] = unsafe { *(result.output.as_ptr() as *const [G; OUT_603]) }; __ret } else { aiur_fn_603(__args, record, io_buffer, __cu)? } };
+    let __v_17: G = __r_arr[0];
+    let __r_arr: [G; OUT_621] = { let __args: [G; IN_621] = [__v_8, __v_9, __v_4, __v_11, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[621].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_621] = unsafe { *(result.output.as_ptr() as *const [G; OUT_621]) }; __ret } else { aiur_fn_621(__args, record, io_buffer, __cu)? } };
+    let __v_18: G = __r_arr[0];
+    let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } else { aiur_fn_711(__args, record, io_buffer, __cu)? } };
+    let __v_19: G = __r_arr[0];
+    let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_16, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } };
+    let __v_20: G = __r_arr[0];
+    let __v_21: G = (__v_11 + __v_19);
+    let __v_22: G = G::from_u64(0);
+    let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_20, __v_21, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } };
+    let __v_23: G = __r_arr[0];
+    let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[589].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_589] = unsafe { *(result.output.as_ptr() as *const [G; OUT_589]) }; __ret } else { aiur_fn_589(__args, record, io_buffer, __cu)? } };
+    let __v_24: G = __r_arr[0];
+    let __v_25: G = __r_arr[1];
+    let __v_26: G = __r_arr[2];
+    let __v_27: G = __r_arr[3];
+    let __v_28: G = G::from_u64(2);
+    let __v_29: G = G::from_u64(0);
+    let __v_30: G = { let __values: [G; 4] = [__v_28, __v_24, __v_27, __v_29]; 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_31: G = (__v_4 + __v_11);
+    let __v_32: G = (__v_31 + __v_19);
+    let __v_33: G = (__v_32 + __v_5);
+    let __v_34: G = G::from_u64(1);
+    let __v_35: G = (__v_33 - __v_34);
+    let __v_36: G = (__v_11 + __v_19);
+    let __v_37: G = (__v_36 + __v_5);
+    let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_30, __v_4, __v_35, __v_37, __v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } };
+    let __v_38: G = __r_arr[0];
+    let __v_39: G = G::from_u64(0);
+    let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_38, __v_5, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } else { aiur_fn_596(__args, record, io_buffer, __cu)? } };
+    let __v_40: G = __r_arr[0];
+    let __v_41: G = G::from_u64(1);
+    let __v_42: G = (__v_33 + __v_41);
+    let __v_43: G = G::from_u64(1);
+    let __v_44: G = (__v_42 - __v_43);
+    let __v_45: G = (__v_4 + __v_10);
+    let __v_46: G = (__v_44 - __v_45);
+    let __v_47: G = G::from_u64(0);
+    let __v_48: G = G::from_u64(0);
+    let __v_49: G = { let __values: [G; 4] = [__v_47, __v_46, __v_48, __v_48]; 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_50: G = G::from_u64(0);
+    let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = [__v_49, __v_5, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[601].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_601] = unsafe { *(result.output.as_ptr() as *const [G; OUT_601]) }; __ret } else { aiur_fn_601(__args, record, io_buffer, __cu)? } };
+    let __v_51: G = __r_arr[0];
+    let __v_52: G = G::from_u64(3);
+    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 = { let __values: [G; 4] = [__v_53, __v_54, __v_55, __v_55]; 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_57: G = G::from_u64(0);
+    let __v_58: G = { let __values: [G; 4] = [__v_52, __v_51, __v_56, __v_57]; 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_59: G = G::from_u64(5);
+    let __v_60: G = G::from_u64(0);
+    let __v_61: G = { let __values: [G; 4] = [__v_59, __v_40, __v_58, __v_60]; 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_597] = { let __args: [G; IN_597] = [__v_61, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[597].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_597] = unsafe { *(result.output.as_ptr() as *const [G; OUT_597]) }; __ret } else { aiur_fn_597(__args, record, io_buffer, __cu)? } };
+    let __v_62: G = __r_arr[0];
+    let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = [__v_62, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[597].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_597] = unsafe { *(result.output.as_ptr() as *const [G; OUT_597]) }; __ret } else { aiur_fn_597(__args, record, io_buffer, __cu)? } };
+    let __v_63: G = __r_arr[0];
+    let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = [__v_63, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[597].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_597] = unsafe { *(result.output.as_ptr() as *const [G; OUT_597]) }; __ret } else { aiur_fn_597(__args, record, io_buffer, __cu)? } };
+    let __v_64: G = __r_arr[0];
+    let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = [__v_64, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[597].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_597] = unsafe { *(result.output.as_ptr() as *const [G; OUT_597]) }; __ret } else { aiur_fn_597(__args, record, io_buffer, __cu)? } };
+    let __v_65: G = __r_arr[0];
+    let __ret: [G; OUT_607] = [__v_65];
+    record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_681: usize = 25;
-const IN_681: usize = 25;
-const OUT_681: usize = 2;
-fn aiur_fn_681(
-  inp: [G; IN_681],
+const INPUT_SIZE_608: usize = 26;
+const IN_608: usize = 26;
+const OUT_608: usize = 0;
+fn aiur_fn_608(
+  inp: [G; IN_608],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_681], ExecError> {
+) -> Result<[G; OUT_608], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -57168,334 +49988,154 @@ fn aiur_fn_681(
     let __v_22: G = inp[22];
     let __v_23: G = inp[23];
     let __v_24: G = inp[24];
+    let __v_25: G = inp[25];
     match __v_0.as_canonical_u64() {
-      1u64 => {
-        match __v_11.as_canonical_u64() {
-          1u64 => {
-            let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = unsafe { *(result.output.as_ptr() as *const [G; OUT_654]) }; __ret } else { aiur_fn_654(__args, record, io_buffer, __cu)? } };
-            let __v_25: G = __r_arr[0];
-            let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } };
-            let __v_26: G = __r_arr[0];
-            let __v_27: G = __r_arr[1];
-            let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_2, __v_13, __v_22, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[670].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_670] = unsafe { *(result.output.as_ptr() as *const [G; OUT_670]) }; __ret } else { aiur_fn_670(__args, record, io_buffer, __cu)? } };
-            let __v_28: G = __r_arr[0];
-            let __v_29: G = __r_arr[1];
-            let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_3, __v_14, __v_22, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[670].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_670] = unsafe { *(result.output.as_ptr() as *const [G; OUT_670]) }; __ret } else { aiur_fn_670(__args, record, io_buffer, __cu)? } };
-            let __v_30: G = __r_arr[0];
-            let __v_31: G = __r_arr[1];
-            let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_28, __v_29, __v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } };
-            let __v_32: G = __r_arr[0];
-            let __v_33: G = __r_arr[1];
-            let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_26, __v_27, __v_32, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } };
-            let __v_34: G = __r_arr[0];
-            let __v_35: G = __r_arr[1];
-            let __ret: [G; OUT_681] = [__v_34, __v_35];
-            record.function_queries[681].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64()));
-          },
-        }
-      },
-      2u64 => {
-        match __v_11.as_canonical_u64() {
-          2u64 => {
-            let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = unsafe { *(result.output.as_ptr() as *const [G; OUT_654]) }; __ret } else { aiur_fn_654(__args, record, io_buffer, __cu)? } };
-            let __v_25: G = __r_arr[0];
-            let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } };
-            let __v_26: G = __r_arr[0];
-            let __v_27: G = __r_arr[1];
-            let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_2, __v_13, __v_22, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[670].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_670] = unsafe { *(result.output.as_ptr() as *const [G; OUT_670]) }; __ret } else { aiur_fn_670(__args, record, io_buffer, __cu)? } };
-            let __v_28: G = __r_arr[0];
-            let __v_29: G = __r_arr[1];
-            let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_3, __v_14, __v_22, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[670].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_670] = unsafe { *(result.output.as_ptr() as *const [G; OUT_670]) }; __ret } else { aiur_fn_670(__args, record, io_buffer, __cu)? } };
-            let __v_30: G = __r_arr[0];
-            let __v_31: G = __r_arr[1];
-            let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_28, __v_29, __v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } };
-            let __v_32: G = __r_arr[0];
-            let __v_33: G = __r_arr[1];
-            let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_26, __v_27, __v_32, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } };
-            let __v_34: G = __r_arr[0];
-            let __v_35: G = __r_arr[1];
-            let __ret: [G; OUT_681] = [__v_34, __v_35];
-            record.function_queries[681].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64()));
-          },
-        }
-      },
-      3u64 => {
-        match __v_11.as_canonical_u64() {
-          3u64 => {
-            let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = unsafe { *(result.output.as_ptr() as *const [G; OUT_654]) }; __ret } else { aiur_fn_654(__args, record, io_buffer, __cu)? } };
-            let __v_25: G = __r_arr[0];
-            let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } };
-            let __v_26: G = __r_arr[0];
-            let __v_27: G = __r_arr[1];
-            let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_2, __v_13, __v_22, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[670].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_670] = unsafe { *(result.output.as_ptr() as *const [G; OUT_670]) }; __ret } else { aiur_fn_670(__args, record, io_buffer, __cu)? } };
-            let __v_28: G = __r_arr[0];
-            let __v_29: G = __r_arr[1];
-            let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_3, __v_14, __v_22, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[670].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_670] = unsafe { *(result.output.as_ptr() as *const [G; OUT_670]) }; __ret } else { aiur_fn_670(__args, record, io_buffer, __cu)? } };
-            let __v_30: G = __r_arr[0];
-            let __v_31: G = __r_arr[1];
-            let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_4, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = unsafe { *(result.output.as_ptr() as *const [G; OUT_654]) }; __ret } else { aiur_fn_654(__args, record, io_buffer, __cu)? } };
-            let __v_32: G = __r_arr[0];
-            let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } };
-            let __v_33: G = __r_arr[0];
-            let __v_34: G = __r_arr[1];
-            let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_30, __v_31, __v_33, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } };
-            let __v_35: G = __r_arr[0];
-            let __v_36: G = __r_arr[1];
-            let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_28, __v_29, __v_35, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } };
-            let __v_37: G = __r_arr[0];
-            let __v_38: G = __r_arr[1];
-            let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_26, __v_27, __v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } };
-            let __v_39: G = __r_arr[0];
-            let __v_40: G = __r_arr[1];
-            let __ret: [G; OUT_681] = [__v_39, __v_40];
-            record.function_queries[681].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64()));
-          },
-        }
-      },
-      4u64 => {
-        match __v_11.as_canonical_u64() {
-          4u64 => {
-            let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = unsafe { *(result.output.as_ptr() as *const [G; OUT_654]) }; __ret } else { aiur_fn_654(__args, record, io_buffer, __cu)? } };
-            let __v_25: G = __r_arr[0];
-            let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } };
-            let __v_26: G = __r_arr[0];
-            let __v_27: G = __r_arr[1];
-            let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_2, __v_13, __v_22, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[670].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_670] = unsafe { *(result.output.as_ptr() as *const [G; OUT_670]) }; __ret } else { aiur_fn_670(__args, record, io_buffer, __cu)? } };
-            let __v_28: G = __r_arr[0];
-            let __v_29: G = __r_arr[1];
-            let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_26, __v_27, __v_28, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } };
-            let __v_30: G = __r_arr[0];
-            let __v_31: G = __r_arr[1];
-            let __ret: [G; OUT_681] = [__v_30, __v_31];
-            record.function_queries[681].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64()));
-          },
-        }
-      },
-      0u64 => {
-        match __v_11.as_canonical_u64() {
-          0u64 => {
-            let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = unsafe { *(result.output.as_ptr() as *const [G; OUT_654]) }; __ret } else { aiur_fn_654(__args, record, io_buffer, __cu)? } };
-            let __v_25: G = __r_arr[0];
-            let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } };
-            let __v_26: G = __r_arr[0];
-            let __v_27: G = __r_arr[1];
-            let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_2, __v_13, __v_22, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[670].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_670] = unsafe { *(result.output.as_ptr() as *const [G; OUT_670]) }; __ret } else { aiur_fn_670(__args, record, io_buffer, __cu)? } };
-            let __v_28: G = __r_arr[0];
-            let __v_29: G = __r_arr[1];
-            let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_3, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = unsafe { *(result.output.as_ptr() as *const [G; OUT_654]) }; __ret } else { aiur_fn_654(__args, record, io_buffer, __cu)? } };
-            let __v_30: G = __r_arr[0];
-            let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } };
-            let __v_31: G = __r_arr[0];
-            let __v_32: G = __r_arr[1];
-            let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_28, __v_29, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } };
-            let __v_33: G = __r_arr[0];
-            let __v_34: G = __r_arr[1];
-            let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_26, __v_27, __v_33, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } };
-            let __v_35: G = __r_arr[0];
-            let __v_36: G = __r_arr[1];
-            let __ret: [G; OUT_681] = [__v_35, __v_36];
-            record.function_queries[681].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64()));
-          },
-        }
-      },
-      5u64 => {
-        match __v_11.as_canonical_u64() {
+      7u64 => {
+        match __v_13.as_canonical_u64() {
           5u64 => {
-            let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_6, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = unsafe { *(result.output.as_ptr() as *const [G; OUT_654]) }; __ret } else { aiur_fn_654(__args, record, io_buffer, __cu)? } };
-            let __v_25: G = __r_arr[0];
-            let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } };
-            let __v_26: G = __r_arr[0];
-            let __v_27: G = __r_arr[1];
-            let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = unsafe { *(result.output.as_ptr() as *const [G; OUT_654]) }; __ret } else { aiur_fn_654(__args, record, io_buffer, __cu)? } };
-            let __v_28: G = __r_arr[0];
-            let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } };
-            let __v_29: G = __r_arr[0];
-            let __v_30: G = __r_arr[1];
-            let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_3, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = unsafe { *(result.output.as_ptr() as *const [G; OUT_654]) }; __ret } else { aiur_fn_654(__args, record, io_buffer, __cu)? } };
-            let __v_31: G = __r_arr[0];
-            let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } };
-            let __v_32: G = __r_arr[0];
-            let __v_33: G = __r_arr[1];
-            let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_4, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = unsafe { *(result.output.as_ptr() as *const [G; OUT_654]) }; __ret } else { aiur_fn_654(__args, record, io_buffer, __cu)? } };
-            let __v_34: G = __r_arr[0];
-            let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } };
-            let __v_35: G = __r_arr[0];
-            let __v_36: G = __r_arr[1];
-            let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { 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_37: G = __r_arr[0];
-            let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { 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_38: G = __r_arr[0];
-            let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = unsafe { *(result.output.as_ptr() as *const [G; OUT_654]) }; __ret } else { aiur_fn_654(__args, record, io_buffer, __cu)? } };
-            let __v_39: G = __r_arr[0];
-            let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } };
-            let __v_40: G = __r_arr[0];
-            let __v_41: G = __r_arr[1];
-            let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_2, __v_13, __v_22, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[670].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_670] = unsafe { *(result.output.as_ptr() as *const [G; OUT_670]) }; __ret } else { aiur_fn_670(__args, record, io_buffer, __cu)? } };
-            let __v_42: G = __r_arr[0];
-            let __v_43: G = __r_arr[1];
-            let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_5, __v_16, __v_22, __v_23, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[682].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_682] = unsafe { *(result.output.as_ptr() as *const [G; OUT_682]) }; __ret } else { aiur_fn_682(__args, record, io_buffer, __cu)? } };
+            let __mc_out___mc_0: [G; 13] = '__mc_0: { match __v_18.as_canonical_u64() {
+  1u64 => {
+    let __v_26: G = G::from_u64(0);
+    let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_20, __v_21, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[261].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_261] = unsafe { *(result.output.as_ptr() as *const [G; OUT_261]) }; __ret } else { aiur_fn_261(__args, record, io_buffer, __cu)? } };
+    let __v_27: G = __r_arr[0];
+    let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; 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: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+    let __v_28: G = __loaded[0];
+    let __v_29: G = __loaded[1];
+    let __v_30: G = __loaded[2];
+    let __v_31: G = __loaded[3];
+    let __v_32: G = __loaded[4];
+    let __v_33: G = __loaded[5];
+    let __v_34: G = __loaded[6];
+    let __v_35: G = __loaded[7];
+    let __v_36: G = __loaded[8];
+    let __v_37: G = __loaded[9];
+    let __v_38: G = __loaded[10];
+    let __v_39: G = __loaded[11];
+    let __v_40: G = G::from_u64(1);
+    break '__mc_0 [__v_40, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39];
+  },
+  _ => {
+    let __v_26: G = G::from_u64(0);
+    let __v_27: G = G::from_u64(0);
+    let __v_28: G = G::from_u64(0);
+    let __v_29: G = G::from_u64(1);
+    let __v_30: G = G::from_u64(0);
+    let __v_31: G = G::from_u64(0);
+    let __v_32: G = { let __values: [G; 3] = [__v_30, __v_31, __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 = G::from_u64(0);
+    let __v_34: G = { let __values: [G; 4] = [__v_29, __v_32, __v_33, __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 __v_35: G = G::from_u64(0);
+    let __v_36: G = G::from_u64(0);
+    break '__mc_0 [__v_26, __v_27, __v_28, __v_34, __v_35, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36];
+  },
+}
+ };
+            let __v_26: G = __mc_out___mc_0[0];
+            let __v_27: G = __mc_out___mc_0[1];
+            let __v_28: G = __mc_out___mc_0[2];
+            let __v_29: G = __mc_out___mc_0[3];
+            let __v_30: G = __mc_out___mc_0[4];
+            let __v_31: G = __mc_out___mc_0[5];
+            let __v_32: G = __mc_out___mc_0[6];
+            let __v_33: G = __mc_out___mc_0[7];
+            let __v_34: G = __mc_out___mc_0[8];
+            let __v_35: G = __mc_out___mc_0[9];
+            let __v_36: G = __mc_out___mc_0[10];
+            let __v_37: G = __mc_out___mc_0[11];
+            let __v_38: G = __mc_out___mc_0[12];
+            let __v_39: G = (__v_16 + __v_17);
+            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_542] = { let __args: [G; IN_542] = [__v_15, __v_39, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } else { aiur_fn_542(__args, record, io_buffer, __cu)? } };
+            let __v_43: G = __r_arr[0];
+            let __r_arr: [G; OUT_561] = { let __args: [G; IN_561] = [__v_43, __v_18, __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]; let __cu = unconstrained; if let Some(result) = record.function_queries[561].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_561] = unsafe { *(result.output.as_ptr() as *const [G; OUT_561]) }; __ret } else { aiur_fn_561(__args, record, io_buffer, __cu)? } };
             let __v_44: G = __r_arr[0];
-            let __v_45: G = __r_arr[1];
-            let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_42, __v_43, __v_44, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } };
-            let __v_46: G = __r_arr[0];
-            let __v_47: G = __r_arr[1];
-            let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_40, __v_41, __v_46, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } };
+            let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_44.as_canonical_u64() {
+  1u64 => {
+    let __v_45: G = G::from_u64(4);
+    let __v_46: G = G::from_u64(0);
+    let __v_47: G = G::from_u64(0);
+    let __v_48: G = { let __values: [G; 3] = [__v_45, __v_46, __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 } };
+    break '__mc_1 [__v_48];
+  },
+  _ => {
+    let __v_45: G = G::from_u64(0);
+    let __v_46: G = G::from_u64(0);
+    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 } };
+    break '__mc_1 [__v_47];
+  },
+}
+ };
+            let __v_45: G = __mc_out___mc_1[0];
+            let __v_46: G = G::from_u64(0);
+            let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_1, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[641].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_641] = unsafe { *(result.output.as_ptr() as *const [G; OUT_641]) }; __ret } else { aiur_fn_641(__args, record, io_buffer, __cu)? } };
+            let __v_47: G = __r_arr[0];
+            let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_10, __v_20, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[584].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_584] = unsafe { *(result.output.as_ptr() as *const [G; OUT_584]) }; __ret } else { aiur_fn_584(__args, record, io_buffer, __cu)? } };
             let __v_48: G = __r_arr[0];
-            let __v_49: G = __r_arr[1];
-            let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_35, __v_36, __v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_615] = { let __args: [G; IN_615] = [__v_48, __v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[615].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_615] = unsafe { *(result.output.as_ptr() as *const [G; OUT_615]) }; __ret } else { aiur_fn_615(__args, record, io_buffer, __cu)? } };
+            let __v_49: G = __r_arr[0];
+            let __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[618].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_618] = unsafe { *(result.output.as_ptr() as *const [G; OUT_618]) }; __ret } else { aiur_fn_618(__args, record, io_buffer, __cu)? } };
             let __v_50: G = __r_arr[0];
-            let __v_51: G = __r_arr[1];
-            let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_32, __v_33, __v_50, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_568] = { let __args: [G; IN_568] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[568].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_568] = unsafe { *(result.output.as_ptr() as *const [G; OUT_568]) }; __ret } else { aiur_fn_568(__args, record, io_buffer, __cu)? } };
+            let __v_51: G = __r_arr[0];
+            let __r_arr: [G; OUT_568] = { let __args: [G; IN_568] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[568].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_568] = unsafe { *(result.output.as_ptr() as *const [G; OUT_568]) }; __ret } else { aiur_fn_568(__args, record, io_buffer, __cu)? } };
             let __v_52: G = __r_arr[0];
-            let __v_53: G = __r_arr[1];
-            let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_29, __v_30, __v_52, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } };
+            let __v_53: G = G::from_u64(1);
+            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_10, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_54: G = __r_arr[0];
-            let __v_55: G = __r_arr[1];
-            let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_26, __v_27, __v_54, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } };
-            let __v_56: G = __r_arr[0];
-            let __v_57: G = __r_arr[1];
-            let __ret: [G; OUT_681] = [__v_56, __v_57];
-            record.function_queries[681].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64()));
-          },
-        }
-      },
-      6u64 => {
-        match __v_11.as_canonical_u64() {
-          6u64 => {
-            let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = unsafe { *(result.output.as_ptr() as *const [G; OUT_654]) }; __ret } else { aiur_fn_654(__args, record, io_buffer, __cu)? } };
-            let __v_25: G = __r_arr[0];
-            let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } };
-            let __v_26: G = __r_arr[0];
-            let __v_27: G = __r_arr[1];
-            let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_4, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = unsafe { *(result.output.as_ptr() as *const [G; OUT_654]) }; __ret } else { aiur_fn_654(__args, record, io_buffer, __cu)? } };
-            let __v_28: G = __r_arr[0];
-            let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } };
-            let __v_29: G = __r_arr[0];
-            let __v_30: G = __r_arr[1];
-            let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_5, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = unsafe { *(result.output.as_ptr() as *const [G; OUT_654]) }; __ret } else { aiur_fn_654(__args, record, io_buffer, __cu)? } };
-            let __v_31: G = __r_arr[0];
-            let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } };
-            let __v_32: G = __r_arr[0];
-            let __v_33: G = __r_arr[1];
-            let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_6, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = unsafe { *(result.output.as_ptr() as *const [G; OUT_654]) }; __ret } else { aiur_fn_654(__args, record, io_buffer, __cu)? } };
-            let __v_34: G = __r_arr[0];
-            let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } };
-            let __v_35: G = __r_arr[0];
-            let __v_36: G = __r_arr[1];
-            let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_2, __v_13, __v_22, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[670].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_670] = unsafe { *(result.output.as_ptr() as *const [G; OUT_670]) }; __ret } else { aiur_fn_670(__args, record, io_buffer, __cu)? } };
-            let __v_37: G = __r_arr[0];
-            let __v_38: G = __r_arr[1];
-            let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_35, __v_36, __v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } };
-            let __v_39: G = __r_arr[0];
-            let __v_40: G = __r_arr[1];
-            let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_32, __v_33, __v_39, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } };
-            let __v_41: G = __r_arr[0];
-            let __v_42: G = __r_arr[1];
-            let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_29, __v_30, __v_41, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } };
-            let __v_43: G = __r_arr[0];
-            let __v_44: G = __r_arr[1];
-            let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_26, __v_27, __v_43, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } };
-            let __v_45: G = __r_arr[0];
-            let __v_46: G = __r_arr[1];
-            let __ret: [G; OUT_681] = [__v_45, __v_46];
-            record.function_queries[681].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64()));
-          },
-        }
-      },
-      7u64 => {
-        match __v_11.as_canonical_u64() {
-          7u64 => {
-            let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = unsafe { *(result.output.as_ptr() as *const [G; OUT_654]) }; __ret } else { aiur_fn_654(__args, record, io_buffer, __cu)? } };
-            let __v_25: G = __r_arr[0];
-            let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } };
-            let __v_26: G = __r_arr[0];
-            let __v_27: G = __r_arr[1];
-            let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_3, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = unsafe { *(result.output.as_ptr() as *const [G; OUT_654]) }; __ret } else { aiur_fn_654(__args, record, io_buffer, __cu)? } };
-            let __v_28: G = __r_arr[0];
-            let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } };
-            let __v_29: G = __r_arr[0];
-            let __v_30: G = __r_arr[1];
-            let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_4, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = unsafe { *(result.output.as_ptr() as *const [G; OUT_654]) }; __ret } else { aiur_fn_654(__args, record, io_buffer, __cu)? } };
-            let __v_31: G = __r_arr[0];
-            let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } };
-            let __v_32: G = __r_arr[0];
-            let __v_33: G = __r_arr[1];
-            let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_5, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = unsafe { *(result.output.as_ptr() as *const [G; OUT_654]) }; __ret } else { aiur_fn_654(__args, record, io_buffer, __cu)? } };
-            let __v_34: G = __r_arr[0];
-            let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } };
-            let __v_35: G = __r_arr[0];
-            let __v_36: G = __r_arr[1];
-            let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_6, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = unsafe { *(result.output.as_ptr() as *const [G; OUT_654]) }; __ret } else { aiur_fn_654(__args, record, io_buffer, __cu)? } };
-            let __v_37: G = __r_arr[0];
-            let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } };
-            let __v_38: G = __r_arr[0];
-            let __v_39: G = __r_arr[1];
-            let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_8, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = unsafe { *(result.output.as_ptr() as *const [G; OUT_654]) }; __ret } else { aiur_fn_654(__args, record, io_buffer, __cu)? } };
-            let __v_40: G = __r_arr[0];
-            let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } };
-            let __v_41: G = __r_arr[0];
-            let __v_42: G = __r_arr[1];
-            let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_2, __v_13, __v_22, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[670].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_670] = unsafe { *(result.output.as_ptr() as *const [G; OUT_670]) }; __ret } else { aiur_fn_670(__args, record, io_buffer, __cu)? } };
-            let __v_43: G = __r_arr[0];
-            let __v_44: G = __r_arr[1];
-            let __r_arr: [G; OUT_678] = { let __args: [G; IN_678] = [__v_7, __v_18, __v_22, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[678].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_678] = unsafe { *(result.output.as_ptr() as *const [G; OUT_678]) }; __ret } else { aiur_fn_678(__args, record, io_buffer, __cu)? } };
-            let __v_45: G = __r_arr[0];
-            let __v_46: G = __r_arr[1];
-            let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_43, __v_44, __v_45, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } };
-            let __v_47: G = __r_arr[0];
-            let __v_48: G = __r_arr[1];
-            let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_41, __v_42, __v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } };
-            let __v_49: G = __r_arr[0];
-            let __v_50: G = __r_arr[1];
-            let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_38, __v_39, __v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } };
-            let __v_51: G = __r_arr[0];
-            let __v_52: G = __r_arr[1];
-            let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_35, __v_36, __v_51, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } };
-            let __v_53: G = __r_arr[0];
-            let __v_54: G = __r_arr[1];
-            let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_32, __v_33, __v_53, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } };
-            let __v_55: G = __r_arr[0];
-            let __v_56: G = __r_arr[1];
-            let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_29, __v_30, __v_55, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } };
-            let __v_57: G = __r_arr[0];
-            let __v_58: G = __r_arr[1];
-            let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_26, __v_27, __v_57, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } };
-            let __v_59: G = __r_arr[0];
-            let __v_60: G = __r_arr[1];
-            let __ret: [G; OUT_681] = [__v_59, __v_60];
-            record.function_queries[681].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
+            let __v_55: G = (__v_53 - __v_54);
+            let __v_56: G = (__v_52 * __v_55);
+            let __v_57: G = (__v_51 * __v_56);
+            let __mc_out___mc_2: [G; 1] = '__mc_2: { match __v_57.as_canonical_u64() {
+  1u64 => {
+    let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__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_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[581].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_581] = unsafe { *(result.output.as_ptr() as *const [G; OUT_581]) }; __ret } else { aiur_fn_581(__args, record, io_buffer, __cu)? } };
+    let __v_58: G = __r_arr[0];
+    break '__mc_2 [__v_58];
+  },
+  _ => {
+    let __v_58: G = G::from_u64(1);
+    let __v_59: G = G::from_u64(1);
+    let __v_60: G = { let __values: [G; 3] = [__v_58, __v_59, __v_59]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    break '__mc_2 [__v_60];
+  },
+}
+ };
+            let __v_58: G = __mc_out___mc_2[0];
+            let __v_59: G = G::from_u64(0);
+            let __r_arr: [G; OUT_588] = { let __args: [G; IN_588] = [__v_48, __v_25, __v_57, __v_58, __v_59]; let __cu = unconstrained; if let Some(result) = record.function_queries[588].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_588] = unsafe { *(result.output.as_ptr() as *const [G; OUT_588]) }; __ret } else { aiur_fn_588(__args, record, io_buffer, __cu)? } };
+            let __v_60: G = __r_arr[0];
+            let __v_61: G = __r_arr[1];
+            match __v_60.as_canonical_u64() {
+              1u64 => {
+                let __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__v_48, __v_61, __v_18, __v_20, __v_21, __v_3, __v_5, __v_6, __v_47, __v_49, __v_50, __v_7, __v_2, __v_15, __v_14, __v_17, __v_45, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[609].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_609] = unsafe { *(result.output.as_ptr() as *const [G; OUT_609]) }; __ret } else { aiur_fn_609(__args, record, io_buffer, __cu)? } };
+                let __ret: [G; OUT_608] = [];
+                record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                let __v_62: G = G::from_u64(0);
+                let __r_arr: [G; OUT_587] = { let __args: [G; IN_587] = [__v_48, __v_25, __v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[587].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_587] = unsafe { *(result.output.as_ptr() as *const [G; OUT_587]) }; __ret } else { aiur_fn_587(__args, record, io_buffer, __cu)? } };
+                let __v_63: G = __r_arr[0];
+                let __v_64: G = __r_arr[1];
+                match __v_63.as_canonical_u64() {
+                  1u64 => {
+                    let __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__v_48, __v_64, __v_18, __v_20, __v_21, __v_3, __v_5, __v_6, __v_47, __v_49, __v_50, __v_7, __v_2, __v_15, __v_14, __v_17, __v_45, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[609].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_609] = unsafe { *(result.output.as_ptr() as *const [G; OUT_609]) }; __ret } else { aiur_fn_609(__args, record, io_buffer, __cu)? } };
+                    let __ret: [G; OUT_608] = [];
+                    record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
+                  },
+                  _ => {
+                    return Err(ExecError::MatchNoCase(__v_63.as_canonical_u64()));
+                  },
+                }
+              },
+            }
           },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64()));
+            let __ret: [G; OUT_608] = [];
+            record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
           },
         }
       },
@@ -57506,111 +50146,154 @@ fn aiur_fn_681(
   })
 }
 
-const INPUT_SIZE_682: usize = 5;
-const IN_682: usize = 5;
-const OUT_682: usize = 2;
-fn aiur_fn_682(
-  inp: [G; IN_682],
+const INPUT_SIZE_609: usize = 18;
+const IN_609: usize = 18;
+const OUT_609: usize = 0;
+fn aiur_fn_609(
+  inp: [G; IN_609],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_682], ExecError> {
+) -> Result<[G; OUT_609], 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 __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_5: G = __loaded[0];
-    let __v_6: G = __loaded[1];
-    let __v_7: G = __loaded[2];
-    match __v_5.as_canonical_u64() {
-      1u64 => {
-        let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[657].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_657] = unsafe { *(result.output.as_ptr() as *const [G; OUT_657]) }; __ret } else { aiur_fn_657(__args, record, io_buffer, __cu)? } };
-        let __v_8: G = __r_arr[0];
-        let __v_9: G = __r_arr[1];
-        let __ret: [G; OUT_682] = [__v_8, __v_9];
-        record.function_queries[682].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    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 __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[589].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_589] = unsafe { *(result.output.as_ptr() as *const [G; OUT_589]) }; __ret } else { aiur_fn_589(__args, record, io_buffer, __cu)? } };
+    let __v_18: G = __r_arr[0];
+    let __v_19: G = __r_arr[1];
+    let __v_20: G = __r_arr[2];
+    let __v_21: G = __r_arr[3];
+    let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_13, __v_14, __v_5, __v_15, __v_16, __v_17, __v_0, __v_10, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = unsafe { *(result.output.as_ptr() as *const [G; OUT_606]) }; __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } };
+    let __v_22: G = __r_arr[0];
+    let __v_23: G = G::from_u64(0);
+    let __r_arr: [G; OUT_610] = { let __args: [G; IN_610] = [__v_0, __v_1, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[610].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_610] = unsafe { *(result.output.as_ptr() as *const [G; OUT_610]) }; __ret } else { aiur_fn_610(__args, record, io_buffer, __cu)? } };
+    let __v_24: G = __r_arr[0];
+    let __v_25: G = G::from_u64(0);
+    let __r_arr: [G; OUT_611] = { let __args: [G; IN_611] = [__v_2, __v_24, __v_3, __v_4, __v_5, __v_6, __v_7, __v_21, __v_8, __v_0, __v_9, __v_10, __v_19, __v_20, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[611].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_611] = unsafe { *(result.output.as_ptr() as *const [G; OUT_611]) }; __ret } else { aiur_fn_611(__args, record, io_buffer, __cu)? } };
+    let __v_26: G = __r_arr[0];
+    let __v_27: G = G::from_u64(1);
+    let __v_28: G = G::from_u64(1);
+    let __v_29: G = { let __values: [G; 3] = [__v_27, __v_28, __v_28]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_394] = { let __args: [G; IN_394] = [__v_12, __v_22, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } };
+    let __v_30: G = __r_arr[0];
+    let __v_31: G = G::from_u64(1);
+    if (__v_30 != __v_31) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_30.as_canonical_u64(), rhs: __v_31.as_canonical_u64(), msg: Some("recursor's declared type is not def-eq to the canonical reconstruction".to_string()) });
+    }
+    let __v_32: G = G::from_u64(0);
+    let __r_arr: [G; OUT_612] = { let __args: [G; IN_612] = [__v_11, __v_26, __v_5, __v_6, __v_7, __v_3, __v_4, __v_2, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[612].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_612] = unsafe { *(result.output.as_ptr() as *const [G; OUT_612]) }; __ret } else { aiur_fn_612(__args, record, io_buffer, __cu)? } };
+    let __ret: [G; OUT_609] = [];
+    record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_610: usize = 3;
+const IN_610: usize = 3;
+const OUT_610: usize = 1;
+fn aiur_fn_610(
+  inp: [G; IN_610],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_610], 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 = (__v_2 - __v_1);
+    match __v_3.as_canonical_u64() {
+      0u64 => {
+        let __v_4: G = G::from_u64(0);
+        let __ret: [G; OUT_610] = [__v_4];
+        record.function_queries[610].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_8: G = __loaded[0];
-        let __v_9: G = __loaded[1];
-        let __v_10: G = __loaded[2];
-        match __v_8.as_canonical_u64() {
+      _ => {
+        let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; 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: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
+        let __v_4: G = __loaded[0];
+        let __v_5: G = __loaded[1];
+        let __v_6: G = __loaded[2];
+        let __v_7: G = __loaded[3];
+        let __v_8: G = __loaded[4];
+        let __v_9: G = __loaded[5];
+        match __v_4.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[657].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_657] = unsafe { *(result.output.as_ptr() as *const [G; OUT_657]) }; __ret } else { aiur_fn_657(__args, record, io_buffer, __cu)? } };
-            let __v_11: G = __r_arr[0];
-            let __v_12: G = __r_arr[1];
-            let __ret: [G; OUT_682] = [__v_11, __v_12];
-            record.function_queries[682].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __v_10: G = G::from_u64(0);
+            let __ret: [G; OUT_610] = [__v_10];
+            record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-            let __v_11: G = __r_arr[0];
-            let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr };
-            let __v_12: G = __loaded[0];
-            let __v_13: G = __loaded[1];
-            let __v_14: G = __loaded[2];
-            let __v_15: G = __loaded[3];
-            let __v_16: G = __loaded[4];
-            let __v_17: G = __loaded[5];
-            let __v_18: G = __loaded[6];
-            let __v_19: G = __loaded[7];
-            let __v_20: G = __loaded[8];
-            let __v_21: G = __loaded[9];
-            let __v_22: G = __loaded[10];
-            let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_3, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-            let __v_23: G = __r_arr[0];
-            let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_23.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr };
-            let __v_24: G = __loaded[0];
-            let __v_25: G = __loaded[1];
-            let __v_26: G = __loaded[2];
-            let __v_27: G = __loaded[3];
-            let __v_28: G = __loaded[4];
-            let __v_29: G = __loaded[5];
-            let __v_30: G = __loaded[6];
-            let __v_31: G = __loaded[7];
-            let __v_32: G = __loaded[8];
-            let __v_33: G = __loaded[9];
-            let __v_34: G = __loaded[10];
-            let __r_arr: [G; OUT_683] = { let __args: [G; IN_683] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[683].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_683] = unsafe { *(result.output.as_ptr() as *const [G; OUT_683]) }; __ret } else { aiur_fn_683(__args, record, io_buffer, __cu)? } };
-            let __v_35: G = __r_arr[0];
-            let __v_36: G = __r_arr[1];
-            let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_7, __v_10, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[682].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_682] = unsafe { *(result.output.as_ptr() as *const [G; OUT_682]) }; __ret } else { aiur_fn_682(__args, record, io_buffer, __cu)? } };
-            let __v_37: G = __r_arr[0];
-            let __v_38: G = __r_arr[1];
-            let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_35, __v_36, __v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } };
-            let __v_39: G = __r_arr[0];
-            let __v_40: G = __r_arr[1];
-            let __ret: [G; OUT_682] = [__v_39, __v_40];
-            record.function_queries[682].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[258].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_258] = unsafe { *(result.output.as_ptr() as *const [G; OUT_258]) }; __ret } else { aiur_fn_258(__args, record, io_buffer, __cu)? } };
+            let __v_10: G = __r_arr[0];
+            let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; 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: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].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];
+            let __v_21: G = __loaded[10];
+            let __v_22: G = __loaded[11];
+            let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_11.as_canonical_u64() {
+  5u64 => {
+    break '__mc_0 [__v_16];
+  },
+  _ => {
+    let __v_23: G = G::from_u64(0);
+    break '__mc_0 [__v_23];
+  },
+}
+ };
+            let __v_23: G = __mc_out___mc_0[0];
+            let __v_24: G = G::from_u64(1);
+            let __v_25: G = (__v_2 + __v_24);
+            let __r_arr: [G; OUT_610] = { let __args: [G; IN_610] = [__v_9, __v_1, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[610].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_610] = unsafe { *(result.output.as_ptr() as *const [G; OUT_610]) }; __ret } else { aiur_fn_610(__args, record, io_buffer, __cu)? } };
+            let __v_26: G = __r_arr[0];
+            let __v_27: G = (__v_23 + __v_26);
+            let __ret: [G; OUT_610] = [__v_27];
+            record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64()));
+            return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
-      },
     }
   })
 }
 
-const INPUT_SIZE_683: usize = 24;
-const IN_683: usize = 24;
-const OUT_683: usize = 2;
-fn aiur_fn_683(
-  inp: [G; IN_683],
+const INPUT_SIZE_611: usize = 15;
+const IN_611: usize = 15;
+const OUT_611: usize = 1;
+fn aiur_fn_611(
+  inp: [G; IN_611],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_683], ExecError> {
+) -> Result<[G; OUT_611], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -57627,157 +50310,194 @@ fn aiur_fn_683(
     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];
-    match __v_0.as_canonical_u64() {
-      6u64 => {
-        match __v_11.as_canonical_u64() {
+    let __v_15: G = (__v_0 - __v_14);
+    match __v_15.as_canonical_u64() {
+      0u64 => {
+        let __v_16: G = G::from_u64(1);
+        let __v_17: G = G::from_u64(1);
+        let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __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 __ret: [G; OUT_611] = [__v_18];
+        record.function_queries[611].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_2, __v_3, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[261].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_261] = unsafe { *(result.output.as_ptr() as *const [G; OUT_261]) }; __ret } else { aiur_fn_261(__args, record, io_buffer, __cu)? } };
+        let __v_16: G = __r_arr[0];
+        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; 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: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].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];
+        let __v_25: G = __loaded[8];
+        let __v_26: G = __loaded[9];
+        let __v_27: G = __loaded[10];
+        let __v_28: G = __loaded[11];
+        match __v_17.as_canonical_u64() {
           6u64 => {
-            let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = unsafe { *(result.output.as_ptr() as *const [G; OUT_654]) }; __ret } else { aiur_fn_654(__args, record, io_buffer, __cu)? } };
-            let __v_24: G = __r_arr[0];
-            let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } };
-            let __v_25: G = __r_arr[0];
-            let __v_26: G = __r_arr[1];
-            let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_4, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = unsafe { *(result.output.as_ptr() as *const [G; OUT_654]) }; __ret } else { aiur_fn_654(__args, record, io_buffer, __cu)? } };
-            let __v_27: G = __r_arr[0];
-            let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } };
-            let __v_28: G = __r_arr[0];
-            let __v_29: G = __r_arr[1];
-            let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_5, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = unsafe { *(result.output.as_ptr() as *const [G; OUT_654]) }; __ret } else { aiur_fn_654(__args, record, io_buffer, __cu)? } };
+            let __v_29: G = (__v_1 + __v_14);
+            let __r_arr: [G; OUT_614] = { let __args: [G; IN_614] = [__v_19, __v_29, __v_4, __v_5, __v_6, __v_23, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[614].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_614] = unsafe { *(result.output.as_ptr() as *const [G; OUT_614]) }; __ret } else { aiur_fn_614(__args, record, io_buffer, __cu)? } };
             let __v_30: G = __r_arr[0];
-            let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } };
-            let __v_31: G = __r_arr[0];
-            let __v_32: G = __r_arr[1];
-            let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_6, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = unsafe { *(result.output.as_ptr() as *const [G; OUT_654]) }; __ret } else { aiur_fn_654(__args, record, io_buffer, __cu)? } };
-            let __v_33: G = __r_arr[0];
-            let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } };
+            let __v_31: G = G::from_u64(0);
+            let __v_32: G = G::from_u64(1);
+            let __v_33: G = (__v_14 + __v_32);
+            let __r_arr: [G; OUT_611] = { let __args: [G; IN_611] = [__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_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[611].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_611] = unsafe { *(result.output.as_ptr() as *const [G; OUT_611]) }; __ret } else { aiur_fn_611(__args, record, io_buffer, __cu)? } };
             let __v_34: G = __r_arr[0];
-            let __v_35: G = __r_arr[1];
-            let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_2, __v_13, __v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[670].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_670] = unsafe { *(result.output.as_ptr() as *const [G; OUT_670]) }; __ret } else { aiur_fn_670(__args, record, io_buffer, __cu)? } };
-            let __v_36: G = __r_arr[0];
-            let __v_37: G = __r_arr[1];
-            let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_34, __v_35, __v_36, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } };
-            let __v_38: G = __r_arr[0];
-            let __v_39: G = __r_arr[1];
-            let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_31, __v_32, __v_38, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } };
-            let __v_40: G = __r_arr[0];
-            let __v_41: G = __r_arr[1];
-            let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_28, __v_29, __v_40, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } };
-            let __v_42: G = __r_arr[0];
-            let __v_43: G = __r_arr[1];
-            let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_25, __v_26, __v_42, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } };
-            let __v_44: G = __r_arr[0];
-            let __v_45: G = __r_arr[1];
-            let __ret: [G; OUT_683] = [__v_44, __v_45];
-            record.function_queries[683].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __v_35: G = { let __values: [G; 3] = [__v_31, __v_30, __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 __ret: [G; OUT_611] = [__v_35];
+            record.function_queries[611].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[679].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_679] = unsafe { *(result.output.as_ptr() as *const [G; OUT_679]) }; __ret } else { aiur_fn_679(__args, record, io_buffer, __cu)? } };
-            let __v_24: G = __r_arr[0];
-            let __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[679].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_679] = unsafe { *(result.output.as_ptr() as *const [G; OUT_679]) }; __ret } else { aiur_fn_679(__args, record, io_buffer, __cu)? } };
-            let __v_25: G = __r_arr[0];
-            let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_24, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = unsafe { *(result.output.as_ptr() as *const [G; OUT_654]) }; __ret } else { aiur_fn_654(__args, record, io_buffer, __cu)? } };
-            let __v_26: G = __r_arr[0];
-            let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } };
-            let __v_27: G = __r_arr[0];
-            let __v_28: G = __r_arr[1];
-            let __ret: [G; OUT_683] = [__v_27, __v_28];
-            record.function_queries[683].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __v_29: G = G::from_u64(1);
+            let __v_30: G = G::from_u64(1);
+            let __v_31: G = { let __values: [G; 3] = [__v_29, __v_30, __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 __ret: [G; OUT_611] = [__v_31];
+            record.function_queries[611].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
-      _ => {
-        let __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[679].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_679] = unsafe { *(result.output.as_ptr() as *const [G; OUT_679]) }; __ret } else { aiur_fn_679(__args, record, io_buffer, __cu)? } };
-        let __v_24: G = __r_arr[0];
-        let __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[679].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_679] = unsafe { *(result.output.as_ptr() as *const [G; OUT_679]) }; __ret } else { aiur_fn_679(__args, record, io_buffer, __cu)? } };
-        let __v_25: G = __r_arr[0];
-        let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_24, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = unsafe { *(result.output.as_ptr() as *const [G; OUT_654]) }; __ret } else { aiur_fn_654(__args, record, io_buffer, __cu)? } };
-        let __v_26: G = __r_arr[0];
-        let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } };
-        let __v_27: G = __r_arr[0];
-        let __v_28: G = __r_arr[1];
-        let __ret: [G; OUT_683] = [__v_27, __v_28];
-        record.function_queries[683].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
     }
   })
 }
 
-const INPUT_SIZE_684: usize = 2;
-const IN_684: usize = 2;
-const OUT_684: usize = 0;
-fn aiur_fn_684(
-  inp: [G; IN_684],
+const INPUT_SIZE_612: usize = 9;
+const IN_612: usize = 9;
+const OUT_612: usize = 0;
+fn aiur_fn_612(
+  inp: [G; IN_612],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_684], ExecError> {
+) -> Result<[G; OUT_612], 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(0);
-    let __v_3: G = G::from_u64(0);
-    let __v_4: G = G::from_u64(0);
-    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 __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 = 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 __v_24: G = G::from_u64(0);
-    let __v_25: G = G::from_u64(0);
-    let __v_26: G = G::from_u64(0);
-    let __v_27: G = G::from_u64(0);
-    let __v_28: G = G::from_u64(0);
-    let __v_29: G = G::from_u64(0);
-    let __v_30: G = G::from_u64(0);
-    let __v_31: G = G::from_u64(0);
-    let __v_32: G = G::from_u64(0);
-    let __v_33: G = G::from_u64(0);
-    let __v_34: G = { let __values: [G; 32] = [__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]; 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_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 __v_38: G = G::from_u64(0);
-    let __r_arr: [G; OUT_686] = { let __args: [G; IN_686] = [__v_0, __v_34, __v_37, __v_38, __v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[686].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_686] = unsafe { *(result.output.as_ptr() as *const [G; OUT_686]) }; __ret } else { aiur_fn_686(__args, record, io_buffer, __cu)? } };
-    let __ret: [G; OUT_684] = [];
-    record.function_queries[684].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
+    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_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 };
+    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 __ret: [G; OUT_612] = [];
+        record.function_queries[612].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      0u64 => {
+        match __v_10.as_canonical_u64() {
+          _ => {
+            let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_5, __v_6, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[261].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_261] = unsafe { *(result.output.as_ptr() as *const [G; OUT_261]) }; __ret } else { aiur_fn_261(__args, record, io_buffer, __cu)? } };
+            let __v_14: G = __r_arr[0];
+            let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+            let __v_15: G = __loaded[0];
+            let __v_16: G = __loaded[1];
+            let __v_17: G = __loaded[2];
+            let __v_18: G = __loaded[3];
+            let __v_19: G = __loaded[4];
+            let __v_20: G = __loaded[5];
+            let __v_21: G = __loaded[6];
+            let __v_22: G = __loaded[7];
+            let __v_23: G = __loaded[8];
+            let __v_24: G = __loaded[9];
+            let __v_25: G = __loaded[10];
+            let __v_26: G = __loaded[11];
+            let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_15.as_canonical_u64() {
+  6u64 => {
+    if (__v_11 != __v_22) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_22.as_canonical_u64(), msg: Some("recursor rule field count differs from the ctor's".to_string()) });
+    }
+    break '__mc_0 [];
+  },
+  _ => {
+    return Err(ExecError::MatchNoCase(__v_15.as_canonical_u64()));
+  },
+}
+ };
+            if (__v_10 != __v_8) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_10.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("recursor rule is out of ctor order".to_string()) });
+            }
+            let __v_27: G = { let __a_val = __v_10.as_canonical_u64(); let __b_val = __v_7.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_28: G = G::from_u64(1);
+            if (__v_27 != __v_28) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_27.as_canonical_u64(), rhs: __v_28.as_canonical_u64(), msg: Some("recursor rule names a ctor index out of range".to_string()) });
+            }
+            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_29: G = __loaded[0];
+            let __v_30: G = __loaded[1];
+            let __v_31: G = __loaded[2];
+            match __v_29.as_canonical_u64() {
+              1u64 => {
+                let __ret: [G; OUT_612] = [];
+                record.function_queries[612].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              0u64 => {
+                let __v_32: G = (__v_2 + __v_3);
+                let __v_33: G = (__v_32 + __v_4);
+                let __v_34: G = (__v_33 + __v_11);
+                let __v_35: G = G::from_u64(0);
+                let __v_36: G = G::from_u64(1);
+                let __v_37: G = G::from_u64(1);
+                let __v_38: G = { let __values: [G; 3] = [__v_36, __v_37, __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 __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_12, __v_34, __v_35, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[643].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_643] = unsafe { *(result.output.as_ptr() as *const [G; OUT_643]) }; __ret } else { aiur_fn_643(__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];
+                if (__v_40 != __v_34) {
+                  return Err(ExecError::AssertEqMismatch { lhs: __v_40.as_canonical_u64(), rhs: __v_34.as_canonical_u64(), msg: Some("recursor rule rhs has too few binders to peel".to_string()) });
+                }
+                let __v_42: G = G::from_u64(1);
+                let __v_43: G = G::from_u64(1);
+                let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __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 __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_39, __v_30, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } };
+                let __v_45: G = __r_arr[0];
+                let __v_46: G = G::from_u64(1);
+                if (__v_45 != __v_46) {
+                  return Err(ExecError::AssertEqMismatch { lhs: __v_45.as_canonical_u64(), rhs: __v_46.as_canonical_u64(), msg: Some("recursor rule rhs differs from canonical reconstruction".to_string()) });
+                }
+                let __v_47: G = G::from_u64(1);
+                let __v_48: G = (__v_8 + __v_47);
+                let __r_arr: [G; OUT_612] = { let __args: [G; IN_612] = [__v_13, __v_31, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[612].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_612] = unsafe { *(result.output.as_ptr() as *const [G; OUT_612]) }; __ret } else { aiur_fn_612(__args, record, io_buffer, __cu)? } };
+                let __ret: [G; OUT_612] = [];
+                record.function_queries[612].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                return Err(ExecError::MatchNoCase(__v_29.as_canonical_u64()));
+              },
+            }
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64()));
+      },
+    }
   })
 }
 
-const INPUT_SIZE_685: usize = 12;
-const IN_685: usize = 12;
-const OUT_685: usize = 1;
-fn aiur_fn_685(
-  inp: [G; IN_685],
+const INPUT_SIZE_613: usize = 12;
+const IN_613: usize = 12;
+const OUT_613: usize = 1;
+fn aiur_fn_613(
+  inp: [G; IN_613],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_685], ExecError> {
+) -> Result<[G; OUT_613], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -57791,84 +50511,20 @@ fn aiur_fn_685(
     let __v_9: G = inp[9];
     let __v_10: G = inp[10];
     let __v_11: G = inp[11];
-    match __v_0.as_canonical_u64() {
-      5u64 => {
-        let __ret: [G; OUT_685] = [__v_7];
-        record.function_queries[685].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      6u64 => {
-        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-        let __v_12: G = __r_arr[0];
-        let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr };
-        let __v_13: G = __loaded[0];
-        let __v_14: G = __loaded[1];
-        let __v_15: G = __loaded[2];
-        let __v_16: G = __loaded[3];
-        let __v_17: G = __loaded[4];
-        let __v_18: G = __loaded[5];
-        let __v_19: G = __loaded[6];
-        let __v_20: G = __loaded[7];
-        let __v_21: G = __loaded[8];
-        let __v_22: G = __loaded[9];
-        let __v_23: G = __loaded[10];
-        match __v_13.as_canonical_u64() {
-          5u64 => {
-            let __ret: [G; OUT_685] = [__v_20];
-            record.function_queries[685].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            let __v_24: G = G::from_u64(0);
-            let __v_25: G = G::from_u64(0);
-            let __v_26: G = G::from_u64(0);
-            let __v_27: G = G::from_u64(0);
-            let __v_28: G = G::from_u64(0);
-            let __v_29: G = G::from_u64(0);
-            let __v_30: G = G::from_u64(0);
-            let __v_31: G = G::from_u64(0);
-            let __v_32: G = G::from_u64(0);
-            let __v_33: G = G::from_u64(0);
-            let __v_34: G = G::from_u64(0);
-            let __v_35: G = G::from_u64(0);
-            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 = 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 = G::from_u64(0);
-            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 = { let __values: [G; 32] = [__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]; 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_685] = [__v_56];
-            record.function_queries[685].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-        }
-      },
-      7u64 => {
-        let __ret: [G; OUT_685] = [__v_10];
-        record.function_queries[685].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_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 __ret: [G; OUT_613] = [__v_0];
+        record.function_queries[613].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      _ => {
-        let __v_12: G = G::from_u64(0);
-        let __v_13: G = G::from_u64(0);
-        let __v_14: G = G::from_u64(0);
+      0u64 => {
         let __v_15: G = G::from_u64(0);
-        let __v_16: G = G::from_u64(0);
+        let __r_arr: [G; OUT_703] = { let __args: [G; IN_703] = [__v_2, __v_11, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[703].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_703] = unsafe { *(result.output.as_ptr() as *const [G; OUT_703]) }; __ret } else { aiur_fn_703(__args, record, io_buffer, __cu)? } };
+        let __v_16: G = __r_arr[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);
@@ -57896,409 +50552,556 @@ fn aiur_fn_685(
         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 = { let __values: [G; 32] = [__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]; 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_685] = [__v_44];
-        record.function_queries[685].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_686: usize = 6;
-const IN_686: usize = 6;
-const OUT_686: usize = 0;
-fn aiur_fn_686(
-  inp: [G; IN_686],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_686], 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_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_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_688] = { let __args: [G; IN_688] = [__v_1, __v_2, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[688].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_688] = unsafe { *(result.output.as_ptr() as *const [G; OUT_688]) }; __ret } else { aiur_fn_688(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_686] = [];
-        record.function_queries[686].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].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 __v_17: G = __loaded[8];
-        let __v_18: G = __loaded[9];
-        let __v_19: G = __loaded[10];
-        let __r_arr: [G; OUT_685] = { let __args: [G; IN_685] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[685].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_685] = unsafe { *(result.output.as_ptr() as *const [G; OUT_685]) }; __ret } else { aiur_fn_685(__args, record, io_buffer, __cu)? } };
-        let __v_20: G = __r_arr[0];
-        let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_20, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_21: G = __r_arr[0];
-        match __v_21.as_canonical_u64() {
-          1u64 => {
-            let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
-            let __v_22: G = __r_arr[0];
-            let __v_23: G = G::from_u64(1);
-            let __v_24: G = (__v_3 + __v_23);
-            let __r_arr: [G; OUT_686] = { let __args: [G; IN_686] = [__v_8, __v_20, __v_22, __v_24, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[686].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_686] = unsafe { *(result.output.as_ptr() as *const [G; OUT_686]) }; __ret } else { aiur_fn_686(__args, record, io_buffer, __cu)? } };
-            let __ret: [G; OUT_686] = [];
-            record.function_queries[686].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          0u64 => {
-            let __r_arr: [G; OUT_688] = { let __args: [G; IN_688] = [__v_1, __v_2, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[688].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_688] = unsafe { *(result.output.as_ptr() as *const [G; OUT_688]) }; __ret } else { aiur_fn_688(__args, record, io_buffer, __cu)? } };
-            let __r_arr: [G; OUT_687] = { let __args: [G; IN_687] = [__v_20, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[687].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_687] = unsafe { *(result.output.as_ptr() as *const [G; OUT_687]) }; __ret } else { aiur_fn_687(__args, record, io_buffer, __cu)? } };
-            let __v_22: G = __r_arr[0];
-            let __v_23: G = G::from_u64(1);
-            let __v_24: G = (__v_3 + __v_23);
-            let __r_arr: [G; OUT_686] = { let __args: [G; IN_686] = [__v_8, __v_20, __v_22, __v_24, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[686].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_686] = unsafe { *(result.output.as_ptr() as *const [G; OUT_686]) }; __ret } else { aiur_fn_686(__args, record, io_buffer, __cu)? } };
-            let __ret: [G; OUT_686] = [];
-            record.function_queries[686].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_21.as_canonical_u64()));
-          },
-        }
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_687: usize = 2;
-const IN_687: usize = 2;
-const OUT_687: usize = 1;
-fn aiur_fn_687(
-  inp: [G; IN_687],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_687], 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(0);
-    let __v_3: G = G::from_u64(0);
-    let __v_4: G = G::from_u64(0);
-    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 __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 = 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 __v_24: G = G::from_u64(0);
-    let __v_25: G = G::from_u64(0);
-    let __v_26: G = G::from_u64(0);
-    let __v_27: G = G::from_u64(0);
-    let __v_28: G = G::from_u64(0);
-    let __v_29: G = G::from_u64(0);
-    let __v_30: G = G::from_u64(0);
-    let __v_31: G = G::from_u64(0);
-    let __v_32: G = G::from_u64(0);
-    let __v_33: G = G::from_u64(0);
-    let __v_34: G = { let __values: [G; 32] = [__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]; 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_122] = { let __args: [G; IN_122] = [__v_0, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_35: G = __r_arr[0];
-    match __v_35.as_canonical_u64() {
-      1u64 => {
-        let __v_36: G = G::from_u64(1);
-        let __v_37: G = G::from_u64(1);
-        let __v_38: G = { let __values: [G; 3] = [__v_36, __v_37, __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 __ret: [G; OUT_687] = [__v_38];
-        record.function_queries[687].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __v_36: G = G::from_u64(0);
-        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 = { let __values: [G; 3] = [__v_36, __v_1, __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 __ret: [G; OUT_687] = [__v_40];
-        record.function_queries[687].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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 = { let __values: [G; 32] = [__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]; 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_703] = { let __args: [G; IN_703] = [__v_4, __v_16, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[703].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_703] = unsafe { *(result.output.as_ptr() as *const [G; OUT_703]) }; __ret } else { aiur_fn_703(__args, record, io_buffer, __cu)? } };
+        let __v_50: G = __r_arr[0];
+        let __v_51: G = G::from_u64(0);
+        let __r_arr: [G; OUT_703] = { let __args: [G; IN_703] = [__v_5, __v_16, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[703].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_703] = unsafe { *(result.output.as_ptr() as *const [G; OUT_703]) }; __ret } else { aiur_fn_703(__args, record, io_buffer, __cu)? } };
+        let __v_52: G = __r_arr[0];
+        let __v_53: G = (__v_6 + __v_7);
+        let __v_54: G = (__v_53 + __v_8);
+        let __v_55: G = (__v_54 + __v_9);
+        let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_3, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } };
+        let __v_56: G = __r_arr[0];
+        let __v_57: G = (__v_9 - __v_13);
+        let __v_58: G = G::from_u64(0);
+        let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_56, __v_57, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[325].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_325] = unsafe { *(result.output.as_ptr() as *const [G; OUT_325]) }; __ret } else { aiur_fn_325(__args, record, io_buffer, __cu)? } };
+        let __v_59: G = __r_arr[0];
+        let __v_60: G = (__v_7 + __v_8);
+        let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_59, __v_60, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[325].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_325] = unsafe { *(result.output.as_ptr() as *const [G; OUT_325]) }; __ret } else { aiur_fn_325(__args, record, io_buffer, __cu)? } };
+        let __v_61: G = __r_arr[0];
+        let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } else { aiur_fn_627(__args, record, io_buffer, __cu)? } };
+        let __v_62: G = __r_arr[0];
+        let __v_63: G = __r_arr[1];
+        let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } else { aiur_fn_711(__args, record, io_buffer, __cu)? } };
+        let __v_64: G = __r_arr[0];
+        let __v_65: G = (__v_55 + __v_64);
+        let __v_66: G = G::from_u64(2);
+        let __v_67: G = G::from_u64(0);
+        let __v_68: G = { let __values: [G; 4] = [__v_66, __v_50, __v_10, __v_67]; 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_69: G = G::from_u64(1);
+        let __v_70: G = (__v_65 - __v_69);
+        let __v_71: G = G::from_u64(0);
+        let __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_68, __v_6, __v_70, __v_71]; let __cu = unconstrained; if let Some(result) = record.function_queries[604].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_604] = unsafe { *(result.output.as_ptr() as *const [G; OUT_604]) }; __ret } else { aiur_fn_604(__args, record, io_buffer, __cu)? } };
+        let __v_72: G = __r_arr[0];
+        let __v_73: G = G::from_u64(1);
+        let __v_74: G = (__v_65 - __v_73);
+        let __v_75: G = (__v_74 - __v_6);
+        let __v_76: G = G::from_u64(0);
+        let __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_72, __v_7, __v_75, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[604].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_604] = unsafe { *(result.output.as_ptr() as *const [G; OUT_604]) }; __ret } else { aiur_fn_604(__args, record, io_buffer, __cu)? } };
+        let __v_77: G = __r_arr[0];
+        let __v_78: G = G::from_u64(1);
+        let __v_79: G = (__v_65 - __v_78);
+        let __v_80: G = (__v_79 - __v_6);
+        let __v_81: G = (__v_80 - __v_7);
+        let __v_82: G = G::from_u64(0);
+        let __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_77, __v_8, __v_81, __v_82]; let __cu = unconstrained; if let Some(result) = record.function_queries[604].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_604] = unsafe { *(result.output.as_ptr() as *const [G; OUT_604]) }; __ret } else { aiur_fn_604(__args, record, io_buffer, __cu)? } };
+        let __v_83: G = __r_arr[0];
+        let __v_84: G = G::from_u64(1);
+        let __v_85: G = G::from_u64(1);
+        let __v_86: G = { let __values: [G; 3] = [__v_84, __v_85, __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 __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_63, __v_86]; let __cu = unconstrained; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = unsafe { *(result.output.as_ptr() as *const [G; OUT_377]) }; __ret } else { aiur_fn_377(__args, record, io_buffer, __cu)? } };
+        let __v_87: G = __r_arr[0];
+        let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_87]; let __cu = unconstrained; if let Some(result) = record.function_queries[106].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_106] = unsafe { *(result.output.as_ptr() as *const [G; OUT_106]) }; __ret } else { aiur_fn_106(__args, record, io_buffer, __cu)? } };
+        let __v_88: G = __r_arr[0];
+        let __v_89: G = __r_arr[1];
+        let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_89, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } };
+        let __v_90: G = __r_arr[0];
+        let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_83, __v_90]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } };
+        let __v_91: G = __r_arr[0];
+        let __v_92: G = G::from_u64(1);
+        let __v_93: G = (__v_9 - __v_92);
+        let __v_94: G = (__v_93 - __v_13);
+        let __v_95: G = (__v_94 + __v_64);
+        let __v_96: G = G::from_u64(0);
+        let __v_97: G = G::from_u64(0);
+        let __v_98: G = { let __values: [G; 4] = [__v_96, __v_95, __v_97, __v_97]; 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_99: G = G::from_u64(0);
+        let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_98, __v_64, __v_99]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } else { aiur_fn_596(__args, record, io_buffer, __cu)? } };
+        let __v_100: G = __r_arr[0];
+        let __v_101: G = G::from_u64(3);
+        let __v_102: G = G::from_u64(0);
+        let __v_103: G = { let __values: [G; 4] = [__v_101, __v_91, __v_100, __v_102]; 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_605] = { let __args: [G; IN_605] = [__v_103, __v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[605].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_605] = unsafe { *(result.output.as_ptr() as *const [G; OUT_605]) }; __ret } else { aiur_fn_605(__args, record, io_buffer, __cu)? } };
+        let __v_104: G = __r_arr[0];
+        let __v_105: G = G::from_u64(3);
+        let __v_106: G = G::from_u64(0);
+        let __v_107: G = { let __values: [G; 4] = [__v_105, __v_0, __v_104, __v_106]; 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_108: G = G::from_u64(1);
+        let __v_109: G = (__v_11 + __v_108);
+        let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_107, __v_14, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_109]; let __cu = unconstrained; if let Some(result) = record.function_queries[613].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_613] = unsafe { *(result.output.as_ptr() as *const [G; OUT_613]) }; __ret } else { aiur_fn_613(__args, record, io_buffer, __cu)? } };
+        let __v_110: G = __r_arr[0];
+        let __ret: [G; OUT_613] = [__v_110];
+        record.function_queries[613].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_35.as_canonical_u64()));
+        return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_688: usize = 4;
-const IN_688: usize = 4;
-const OUT_688: usize = 0;
-fn aiur_fn_688(
-  inp: [G; IN_688],
+const INPUT_SIZE_614: usize = 13;
+const IN_614: usize = 13;
+const OUT_614: usize = 1;
+fn aiur_fn_614(
+  inp: [G; IN_614],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_688], ExecError> {
+) -> Result<[G; OUT_614], 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(0);
-    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 __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_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 __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } else { aiur_fn_307(__args, record, io_buffer, __cu)? } };
+    let __v_13: G = __r_arr[0];
+    let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_13, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } else { aiur_fn_535(__args, record, io_buffer, __cu)? } };
+    let __v_14: G = __r_arr[0];
     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 __r_arr: [G; OUT_624] = { let __args: [G; IN_624] = [__v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[624].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_624] = unsafe { *(result.output.as_ptr() as *const [G; OUT_624]) }; __ret } else { aiur_fn_624(__args, record, io_buffer, __cu)? } };
+    let __v_16: G = __r_arr[0];
+    let __v_17: G = (__v_2 + __v_3);
+    let __v_18: G = (__v_17 + __v_4);
+    let __v_19: G = (__v_18 + __v_16);
     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 __v_24: G = G::from_u64(0);
-    let __v_25: G = G::from_u64(0);
-    let __v_26: G = G::from_u64(0);
-    let __v_27: G = G::from_u64(0);
-    let __v_28: G = G::from_u64(0);
-    let __v_29: G = G::from_u64(0);
-    let __v_30: G = G::from_u64(0);
-    let __v_31: G = G::from_u64(0);
+    let __r_arr: [G; OUT_625] = { let __args: [G; IN_625] = [__v_13, __v_5, __v_5, __v_20, __v_11, __v_12, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[625].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_625] = unsafe { *(result.output.as_ptr() as *const [G; OUT_625]) }; __ret } else { aiur_fn_625(__args, record, io_buffer, __cu)? } };
+    let __v_22: G = __r_arr[0];
+    let __v_23: G = G::from_u64(1);
+    let __v_24: G = G::from_u64(1);
+    let __v_25: G = { let __values: [G; 3] = [__v_23, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_26: G = G::from_u64(1);
+    let __v_27: G = G::from_u64(1);
+    let __v_28: G = { let __values: [G; 3] = [__v_26, __v_27, __v_27]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_29: G = G::from_u64(1);
+    let __v_30: G = G::from_u64(1);
+    let __v_31: G = { let __values: [G; 3] = [__v_29, __v_30, __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 = G::from_u64(0);
     let __v_33: G = G::from_u64(0);
-    let __v_34: G = G::from_u64(0);
-    let __v_35: G = G::from_u64(0);
-    let __v_36: 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 __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_37: G = __r_arr[0];
-    match __v_37.as_canonical_u64() {
+    let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = [__v_22, __v_8, __v_25, __v_28, __v_31, __v_32, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[637].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_637] = unsafe { *(result.output.as_ptr() as *const [G; OUT_637]) }; __ret } else { aiur_fn_637(__args, record, io_buffer, __cu)? } };
+    let __v_34: G = __r_arr[0];
+    let __v_35: G = __r_arr[1];
+    let __v_36: G = __r_arr[2];
+    let __v_37: G = __r_arr[3];
+    let __v_38: G = G::from_u64(1);
+    let __v_39: G = (__v_19 - __v_38);
+    let __v_40: G = (__v_2 + __v_3);
+    let __v_41: G = (__v_40 + __v_1);
+    let __v_42: G = (__v_39 - __v_41);
+    let __v_43: G = G::from_u64(0);
+    let __v_44: G = G::from_u64(0);
+    let __v_45: G = { let __values: [G; 4] = [__v_43, __v_42, __v_44, __v_44]; 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_46: G = G::from_u64(0);
+    let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_45, __v_16, __v_16, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[631].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_631] = unsafe { *(result.output.as_ptr() as *const [G; OUT_631]) }; __ret } else { aiur_fn_631(__args, record, io_buffer, __cu)? } };
+    let __v_47: G = __r_arr[0];
+    let __v_48: G = G::from_u64(0);
+    let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_47, __v_35, __v_36, __v_34, __v_9, __v_10, __v_2, __v_3, __v_4, __v_16, __v_7, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[613].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_613] = unsafe { *(result.output.as_ptr() as *const [G; OUT_613]) }; __ret } else { aiur_fn_613(__args, record, io_buffer, __cu)? } };
+    let __v_49: G = __r_arr[0];
+    let __ret: [G; OUT_614] = [__v_49];
+    record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_615: usize = 3;
+const IN_615: usize = 3;
+const OUT_615: usize = 1;
+fn aiur_fn_615(
+  inp: [G; IN_615],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_615], 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; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; 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: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
+    let __v_3: G = __loaded[0];
+    let __v_4: G = __loaded[1];
+    let __v_5: G = __loaded[2];
+    let __v_6: G = __loaded[3];
+    let __v_7: G = __loaded[4];
+    let __v_8: G = __loaded[5];
+    match __v_3.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_688] = [];
-        record.function_queries[688].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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 __ret: [G; OUT_615] = [__v_11];
+        record.function_queries[615].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { 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_38: G = __r_arr[0];
-        match __v_38.as_canonical_u64() {
-          0u64 => {
-            let __ret: [G; OUT_688] = [];
-            record.function_queries[688].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          1u64 => {
-            let __ret: [G; OUT_688] = [];
-            record.function_queries[688].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            let __r_arr: [G; OUT_689] = { let __args: [G; IN_689] = [__v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[689].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_689] = unsafe { *(result.output.as_ptr() as *const [G; OUT_689]) }; __ret } else { aiur_fn_689(__args, record, io_buffer, __cu)? } };
-            let __ret: [G; OUT_688] = [];
-            record.function_queries[688].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-        }
+        let __r_arr: [G; OUT_616] = { let __args: [G; IN_616] = [__v_1, __v_4, __v_6, __v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[616].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_616] = unsafe { *(result.output.as_ptr() as *const [G; OUT_616]) }; __ret } else { aiur_fn_616(__args, record, io_buffer, __cu)? } };
+        let __v_9: G = __r_arr[0];
+        let __v_10: G = G::from_u64(0);
+        let __r_arr: [G; OUT_615] = { let __args: [G; IN_615] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[615].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_615] = unsafe { *(result.output.as_ptr() as *const [G; OUT_615]) }; __ret } else { aiur_fn_615(__args, record, io_buffer, __cu)? } };
+        let __v_11: G = __r_arr[0];
+        let __v_12: G = { let __values: [G; 3] = [__v_10, __v_9, __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_615] = [__v_12];
+        record.function_queries[615].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_37.as_canonical_u64()));
+        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_689: usize = 3;
-const IN_689: usize = 3;
-const OUT_689: usize = 0;
-fn aiur_fn_689(
-  inp: [G; IN_689],
+const INPUT_SIZE_616: usize = 5;
+const IN_616: usize = 5;
+const OUT_616: usize = 1;
+fn aiur_fn_616(
+  inp: [G; IN_616],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_689], ExecError> {
+) -> Result<[G; OUT_616], 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_690] = { let __args: [G; IN_690] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[690].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_690] = unsafe { *(result.output.as_ptr() as *const [G; OUT_690]) }; __ret } else { aiur_fn_690(__args, record, io_buffer, __cu)? } };
-    let __v_3: G = __r_arr[0];
-    let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { 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_4: G = __r_arr[0];
-    match __v_4.as_canonical_u64() {
-      0u64 => {
-        let __ret: [G; OUT_689] = [];
-        record.function_queries[689].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      1u64 => {
-        let __ret: [G; OUT_689] = [];
-        record.function_queries[689].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } else { aiur_fn_255(__args, record, io_buffer, __cu)? } };
+    let __v_5: G = __r_arr[0];
+    let __v_6: G = __r_arr[1];
+    let __v_7: G = __r_arr[2];
+    let __v_8: G = __r_arr[3];
+    let __v_9: G = __r_arr[4];
+    let __v_10: G = __r_arr[5];
+    let __v_11: G = __r_arr[6];
+    let __v_12: G = __r_arr[7];
+    let __v_13: G = __r_arr[8];
+    let __v_14: G = __r_arr[9];
+    let __v_15: G = __r_arr[10];
+    let __v_16: G = __r_arr[11];
+    let __v_17: G = __r_arr[12];
+    let __v_18: G = __r_arr[13];
+    let __v_19: G = __r_arr[14];
+    let __v_20: G = __r_arr[15];
+    let __v_21: G = __r_arr[16];
+    let __v_22: G = __r_arr[17];
+    let __v_23: G = __r_arr[18];
+    let __v_24: G = __r_arr[19];
+    let __v_25: G = __r_arr[20];
+    let __v_26: G = __r_arr[21];
+    let __v_27: G = __r_arr[22];
+    let __v_28: G = __r_arr[23];
+    let __v_29: G = __r_arr[24];
+    let __v_30: G = __r_arr[25];
+    let __v_31: G = __r_arr[26];
+    let __v_32: G = __r_arr[27];
+    let __v_33: G = __r_arr[28];
+    let __v_34: G = __r_arr[29];
+    let __v_35: G = __r_arr[30];
+    let __v_36: G = __r_arr[31];
+    let __v_37: G = __r_arr[32];
+    let __v_38: G = __r_arr[33];
+    let __v_39: G = __r_arr[34];
+    let __v_40: G = __r_arr[35];
+    let __v_41: G = __r_arr[36];
+    let __v_42: G = __r_arr[37];
+    let __v_43: G = __r_arr[38];
+    let __v_44: G = __r_arr[39];
+    let __v_45: G = __r_arr[40];
+    let __v_46: G = __r_arr[41];
+    let __v_47: G = __r_arr[42];
+    let __v_48: G = __r_arr[43];
+    let __v_49: G = __r_arr[44];
+    let __v_50: G = __r_arr[45];
+    let __v_51: G = __r_arr[46];
+    let __v_52: G = __r_arr[47];
+    match __v_5.as_canonical_u64() {
       _ => {
-        let __r_arr: [G; OUT_693] = { let __args: [G; IN_693] = [__v_3, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[693].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_693] = unsafe { *(result.output.as_ptr() as *const [G; OUT_693]) }; __ret } else { aiur_fn_693(__args, record, io_buffer, __cu)? } };
-        let __v_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[691].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_691] = unsafe { *(result.output.as_ptr() as *const [G; OUT_691]) }; __ret } else { aiur_fn_691(__args, record, io_buffer, __cu)? } };
-        let __v_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_692] = { let __args: [G; IN_692] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[692].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_692] = unsafe { *(result.output.as_ptr() as *const [G; OUT_692]) }; __ret } else { aiur_fn_692(__args, record, io_buffer, __cu)? } };
-        let __v_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_7, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[231].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_231] = unsafe { *(result.output.as_ptr() as *const [G; OUT_231]) }; __ret } else { aiur_fn_231(__args, record, io_buffer, __cu)? } };
-        let __v_8: G = __r_arr[0];
-        let __v_9: G = G::from_u64(1);
-        if (__v_6 != __v_9) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_9.as_canonical_u64() });
-        }
-        let __v_10: G = G::from_u64(1);
-        if (__v_8 != __v_10) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_8.as_canonical_u64(), rhs: __v_10.as_canonical_u64() });
+        match __v_5.as_canonical_u64() {
+          8u64 => {
+            let __v_53: G = G::from_u64(0);
+            let __r_arr: [G; OUT_617] = { let __args: [G; IN_617] = [__v_6, __v_6, __v_0, __v_1, __v_2, __v_3, __v_4, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[617].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_617] = unsafe { *(result.output.as_ptr() as *const [G; OUT_617]) }; __ret } else { aiur_fn_617(__args, record, io_buffer, __cu)? } };
+            let __v_54: G = __r_arr[0];
+            let __ret: [G; OUT_616] = [__v_54];
+            record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            let __ret: [G; OUT_616] = [__v_4];
+            record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
         }
-        let __ret: [G; OUT_689] = [];
-        record.function_queries[689].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_690: usize = 2;
-const IN_690: usize = 2;
-const OUT_690: usize = 1;
-fn aiur_fn_690(
-  inp: [G; IN_690],
+const INPUT_SIZE_617: usize = 8;
+const IN_617: usize = 8;
+const OUT_617: usize = 1;
+fn aiur_fn_617(
+  inp: [G; IN_617],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_690], ExecError> {
+) -> Result<[G; OUT_617], 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() {
+    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; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; 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: 47 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 47] = __args[..47].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];
+    let __v_18: G = __loaded[10];
+    let __v_19: G = __loaded[11];
+    let __v_20: G = __loaded[12];
+    let __v_21: G = __loaded[13];
+    let __v_22: G = __loaded[14];
+    let __v_23: G = __loaded[15];
+    let __v_24: G = __loaded[16];
+    let __v_25: G = __loaded[17];
+    let __v_26: G = __loaded[18];
+    let __v_27: G = __loaded[19];
+    let __v_28: G = __loaded[20];
+    let __v_29: G = __loaded[21];
+    let __v_30: G = __loaded[22];
+    let __v_31: G = __loaded[23];
+    let __v_32: G = __loaded[24];
+    let __v_33: G = __loaded[25];
+    let __v_34: G = __loaded[26];
+    let __v_35: G = __loaded[27];
+    let __v_36: G = __loaded[28];
+    let __v_37: G = __loaded[29];
+    let __v_38: G = __loaded[30];
+    let __v_39: G = __loaded[31];
+    let __v_40: G = __loaded[32];
+    let __v_41: G = __loaded[33];
+    let __v_42: G = __loaded[34];
+    let __v_43: G = __loaded[35];
+    let __v_44: G = __loaded[36];
+    let __v_45: G = __loaded[37];
+    let __v_46: G = __loaded[38];
+    let __v_47: G = __loaded[39];
+    let __v_48: G = __loaded[40];
+    let __v_49: G = __loaded[41];
+    let __v_50: G = __loaded[42];
+    let __v_51: G = __loaded[43];
+    let __v_52: G = __loaded[44];
+    let __v_53: G = __loaded[45];
+    let __v_54: G = __loaded[46];
+    match __v_8.as_canonical_u64() {
       1u64 => {
-        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_690] = [__v_7];
-        record.function_queries[690].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_617] = [__v_6];
+        record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-        let __v_5: G = __r_arr[0];
-        let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].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];
-        let __v_13: G = __loaded[7];
-        let __v_14: G = __loaded[8];
-        let __v_15: G = __loaded[9];
-        let __v_16: G = __loaded[10];
-        let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[690].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_690] = unsafe { *(result.output.as_ptr() as *const [G; OUT_690]) }; __ret } else { aiur_fn_690(__args, record, io_buffer, __cu)? } };
-        let __v_17: G = __r_arr[0];
-        let __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__v_6, __v_7, __v_8, __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[679].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_679] = unsafe { *(result.output.as_ptr() as *const [G; OUT_679]) }; __ret } else { aiur_fn_679(__args, record, io_buffer, __cu)? } };
-        let __v_18: G = __r_arr[0];
-        match __v_18.as_canonical_u64() {
-          1u64 => {
-            let __v_19: G = G::from_u64(0);
-            let __v_20: G = { let __values: [G; 3] = [__v_19, __v_3, __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 __ret: [G; OUT_690] = [__v_20];
-            record.function_queries[690].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
+        match __v_9.as_canonical_u64() {
+          2u64 => {
+            let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_0, __v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[266].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_266] = unsafe { *(result.output.as_ptr() as *const [G; OUT_266]) }; __ret } else { aiur_fn_266(__args, record, io_buffer, __cu)? } };
+            let __v_55: G = __r_arr[0];
+            let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[258].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_258] = unsafe { *(result.output.as_ptr() as *const [G; OUT_258]) }; __ret } else { aiur_fn_258(__args, record, io_buffer, __cu)? } };
+            let __v_56: G = __r_arr[0];
+            let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_56.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+            let __v_57: G = __loaded[0];
+            let __v_58: G = __loaded[1];
+            let __v_59: G = __loaded[2];
+            let __v_60: G = __loaded[3];
+            let __v_61: G = __loaded[4];
+            let __v_62: G = __loaded[5];
+            let __v_63: G = __loaded[6];
+            let __v_64: G = __loaded[7];
+            let __v_65: G = __loaded[8];
+            let __v_66: G = __loaded[9];
+            let __v_67: G = __loaded[10];
+            let __v_68: G = __loaded[11];
+            let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_57.as_canonical_u64() {
+  7u64 => {
+    let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_59, __v_60, __v_62, __v_63, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[570].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_570] = unsafe { *(result.output.as_ptr() as *const [G; OUT_570]) }; __ret } else { aiur_fn_570(__args, record, io_buffer, __cu)? } };
+    let __v_69: G = __r_arr[0];
+    let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_69]; let __cu = unconstrained; if let Some(result) = record.function_queries[258].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_258] = unsafe { *(result.output.as_ptr() as *const [G; OUT_258]) }; __ret } else { aiur_fn_258(__args, record, io_buffer, __cu)? } };
+    let __v_70: G = __r_arr[0];
+    let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_70.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+    let __v_71: G = __loaded[0];
+    let __v_72: G = __loaded[1];
+    let __v_73: G = __loaded[2];
+    let __v_74: G = __loaded[3];
+    let __v_75: G = __loaded[4];
+    let __v_76: G = __loaded[5];
+    let __v_77: G = __loaded[6];
+    let __v_78: G = __loaded[7];
+    let __v_79: G = __loaded[8];
+    let __v_80: G = __loaded[9];
+    let __v_81: G = __loaded[10];
+    let __v_82: G = __loaded[11];
+    let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_71.as_canonical_u64() {
+  5u64 => {
+    break '__mc_1 [__v_74];
+  },
+  _ => {
+    let __v_83: G = G::from_u64(0);
+    break '__mc_1 [__v_83];
+  },
+}
+ };
+    let __v_83: G = __mc_out___mc_1[0];
+    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_69, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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];
+    match __v_84.as_canonical_u64() {
+      1u64 => {
+        match __v_5.as_canonical_u64() {
+          0u64 => {
+            let __v_85: G = G::from_u64(1);
+            break '__mc_0 [__v_85];
+          },
+          _ => {
+            let __r_arr: [G; OUT_572] = { let __args: [G; IN_572] = [__v_59, __v_60, __v_62, __v_63, __v_61, __v_83]; let __cu = unconstrained; if let Some(result) = record.function_queries[572].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_572] = unsafe { *(result.output.as_ptr() as *const [G; OUT_572]) }; __ret } else { aiur_fn_572(__args, record, io_buffer, __cu)? } };
+            let __v_85: G = __r_arr[0];
+            let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_85, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[580].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_580] = unsafe { *(result.output.as_ptr() as *const [G; OUT_580]) }; __ret } else { aiur_fn_580(__args, record, io_buffer, __cu)? } };
+            let __v_86: G = __r_arr[0];
+            break '__mc_0 [__v_86];
+          },
+        }
+      },
+      _ => {
+        let __v_85: G = G::from_u64(0);
+        break '__mc_0 [__v_85];
+      },
+    }
+  },
+  _ => {
+    let __v_69: G = G::from_u64(0);
+    break '__mc_0 [__v_69];
+  },
+}
+ };
+            let __v_69: G = __mc_out___mc_0[0];
+            match __v_69.as_canonical_u64() {
+              1u64 => {
+                let __ret: [G; OUT_617] = [__v_55];
+                record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                let __v_70: G = G::from_u64(1);
+                let __v_71: G = (__v_7 + __v_70);
+                let __r_arr: [G; OUT_617] = { let __args: [G; IN_617] = [__v_0, __v_54, __v_2, __v_3, __v_4, __v_5, __v_6, __v_71]; let __cu = unconstrained; if let Some(result) = record.function_queries[617].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_617] = unsafe { *(result.output.as_ptr() as *const [G; OUT_617]) }; __ret } else { aiur_fn_617(__args, record, io_buffer, __cu)? } };
+                let __v_72: G = __r_arr[0];
+                let __ret: [G; OUT_617] = [__v_72];
+                record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+            }
           },
           _ => {
-            let __ret: [G; OUT_690] = [__v_17];
-            record.function_queries[690].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __v_55: G = G::from_u64(1);
+            let __v_56: G = (__v_7 + __v_55);
+            let __r_arr: [G; OUT_617] = { let __args: [G; IN_617] = [__v_0, __v_54, __v_2, __v_3, __v_4, __v_5, __v_6, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[617].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_617] = unsafe { *(result.output.as_ptr() as *const [G; OUT_617]) }; __ret } else { aiur_fn_617(__args, record, io_buffer, __cu)? } };
+            let __v_57: G = __r_arr[0];
+            let __ret: [G; OUT_617] = [__v_57];
+            record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+        return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_691: usize = 1;
-const IN_691: usize = 1;
-const OUT_691: usize = 1;
-fn aiur_fn_691(
-  inp: [G; IN_691],
+const INPUT_SIZE_618: usize = 1;
+const IN_618: usize = 1;
+const OUT_618: usize = 1;
+fn aiur_fn_618(
+  inp: [G; IN_618],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_691], ExecError> {
+) -> Result<[G; OUT_618], 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 __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; 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: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].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];
     match __v_1.as_canonical_u64() {
       1u64 => {
-        let __v_4: G = G::from_u64(1);
-        let __ret: [G; OUT_691] = [__v_4];
-        record.function_queries[691].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __v_7: G = G::from_u64(1);
+        let __v_8: G = G::from_u64(1);
+        let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __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_618] = [__v_9];
+        record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { 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_4: G = __r_arr[0];
-        match __v_4.as_canonical_u64() {
-          1u64 => {
-            let __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[691].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_691] = unsafe { *(result.output.as_ptr() as *const [G; OUT_691]) }; __ret } else { aiur_fn_691(__args, record, io_buffer, __cu)? } };
-            let __v_5: G = __r_arr[0];
-            let __ret: [G; OUT_691] = [__v_5];
-            record.function_queries[691].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            let __v_5: G = G::from_u64(0);
-            let __ret: [G; OUT_691] = [__v_5];
-            record.function_queries[691].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-        }
+        let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[258].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_258] = unsafe { *(result.output.as_ptr() as *const [G; OUT_258]) }; __ret } else { aiur_fn_258(__args, record, io_buffer, __cu)? } };
+        let __v_7: G = __r_arr[0];
+        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; 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: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].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];
+        let __v_18: G = __loaded[10];
+        let __v_19: G = __loaded[11];
+        let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_8.as_canonical_u64() {
+  5u64 => {
+    break '__mc_0 [__v_11];
+  },
+  _ => {
+    let __v_20: G = G::from_u64(0);
+    break '__mc_0 [__v_20];
+  },
+}
+ };
+        let __v_20: G = __mc_out___mc_0[0];
+        let __v_21: G = G::from_u64(0);
+        let __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[618].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_618] = unsafe { *(result.output.as_ptr() as *const [G; OUT_618]) }; __ret } else { aiur_fn_618(__args, record, io_buffer, __cu)? } };
+        let __v_22: G = __r_arr[0];
+        let __v_23: G = { let __values: [G; 3] = [__v_21, __v_20, __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_618] = [__v_23];
+        record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
       _ => {
         return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
@@ -58307,116 +51110,301 @@ fn aiur_fn_691(
   })
 }
 
-const INPUT_SIZE_692: usize = 1;
-const IN_692: usize = 1;
-const OUT_692: usize = 1;
-fn aiur_fn_692(
-  inp: [G; IN_692],
+const INPUT_SIZE_619: usize = 3;
+const IN_619: usize = 3;
+const OUT_619: usize = 1;
+fn aiur_fn_619(
+  inp: [G; IN_619],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_692], ExecError> {
+) -> Result<[G; OUT_619], 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(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_692] = [__v_6];
-        record.function_queries[692].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[265].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_265] = unsafe { *(result.output.as_ptr() as *const [G; OUT_265]) }; __ret } else { aiur_fn_265(__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 __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[265].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_265] = unsafe { *(result.output.as_ptr() as *const [G; OUT_265]) }; __ret } else { aiur_fn_265(__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 = G::from_u64(4);
+    let __v_20: G = G::from_u64(0);
+    let __v_21: G = G::from_u64(1);
+    let __v_22: G = G::from_u64(1);
+    let __v_23: G = { let __values: [G; 3] = [__v_21, __v_22, __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 = G::from_u64(1);
+    let __v_25: G = G::from_u64(1);
+    let __v_26: G = { let __values: [G; 3] = [__v_24, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_27: G = G::from_u64(1);
+    let __v_28: G = G::from_u64(1);
+    let __v_29: G = { let __values: [G; 3] = [__v_27, __v_28, __v_28]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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 = G::from_u64(1);
+    let __v_31: G = G::from_u64(1);
+    let __v_32: G = { let __values: [G; 3] = [__v_30, __v_31, __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 __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_19, __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_2, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_23, __v_26, __v_29, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[67].get_mut(&__args[..]) { 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_33: G = __r_arr[0];
+    let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[18].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_18] = unsafe { *(result.output.as_ptr() as *const [G; OUT_18]) }; __ret } else { aiur_fn_18(__args, record, io_buffer, __cu)? } };
+    let __v_34: G = __r_arr[0];
+    let __ret: [G; OUT_619] = [__v_34];
+    record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_620: usize = 15;
+const IN_620: usize = 15;
+const OUT_620: usize = 1;
+fn aiur_fn_620(
+  inp: [G; IN_620],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_620], 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 = (__v_12 - __v_14);
+    match __v_15.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_692] = { let __args: [G; IN_692] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[692].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_692] = unsafe { *(result.output.as_ptr() as *const [G; OUT_692]) }; __ret } else { aiur_fn_692(__args, record, io_buffer, __cu)? } };
-        let __v_4: G = __r_arr[0];
-        let __r_arr: [G; OUT_773] = { let __args: [G; IN_773] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[773].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_773] = unsafe { *(result.output.as_ptr() as *const [G; OUT_773]) }; __ret } else { aiur_fn_773(__args, record, io_buffer, __cu)? } };
-        let __v_5: G = __r_arr[0];
-        let __ret: [G; OUT_692] = [__v_5];
-        record.function_queries[692].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __v_16: G = G::from_u64(1);
+        let __v_17: G = G::from_u64(1);
+        let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __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 __ret: [G; OUT_620] = [__v_18];
+        record.function_queries[620].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+        let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_10, __v_11, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[261].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_261] = unsafe { *(result.output.as_ptr() as *const [G; OUT_261]) }; __ret } else { aiur_fn_261(__args, record, io_buffer, __cu)? } };
+        let __v_16: G = __r_arr[0];
+        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; 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: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].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];
+        let __v_25: G = __loaded[8];
+        let __v_26: G = __loaded[9];
+        let __v_27: G = __loaded[10];
+        let __v_28: G = __loaded[11];
+        match __v_17.as_canonical_u64() {
+          6u64 => {
+            let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_11, __v_14, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[619].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_619] = unsafe { *(result.output.as_ptr() as *const [G; OUT_619]) }; __ret } else { aiur_fn_619(__args, record, io_buffer, __cu)? } };
+            let __v_29: G = __r_arr[0];
+            let __r_arr: [G; OUT_626] = { let __args: [G; IN_626] = [__v_29, __v_19, __v_23, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_13, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[626].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_626] = unsafe { *(result.output.as_ptr() as *const [G; OUT_626]) }; __ret } else { aiur_fn_626(__args, record, io_buffer, __cu)? } };
+            let __v_30: G = __r_arr[0];
+            let __v_31: G = G::from_u64(0);
+            let __v_32: G = G::from_u64(1);
+            let __v_33: G = (__v_13 + __v_32);
+            let __v_34: G = G::from_u64(1);
+            let __v_35: G = (__v_14 + __v_34);
+            let __r_arr: [G; OUT_620] = { let __args: [G; IN_620] = [__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_33, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[620].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_620] = unsafe { *(result.output.as_ptr() as *const [G; OUT_620]) }; __ret } else { aiur_fn_620(__args, record, io_buffer, __cu)? } };
+            let __v_36: G = __r_arr[0];
+            let __v_37: G = { let __values: [G; 3] = [__v_31, __v_30, __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 __ret: [G; OUT_620] = [__v_37];
+            record.function_queries[620].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_17.as_canonical_u64()));
+          },
+        }
       },
     }
   })
 }
 
-const INPUT_SIZE_693: usize = 3;
-const IN_693: usize = 3;
-const OUT_693: usize = 1;
-fn aiur_fn_693(
-  inp: [G; IN_693],
+const INPUT_SIZE_621: usize = 5;
+const IN_621: usize = 5;
+const OUT_621: usize = 1;
+fn aiur_fn_621(
+  inp: [G; IN_621],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_693], ExecError> {
+) -> Result<[G; OUT_621], 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 = G::from_u64(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 __v_7: G = { let __values: [G; 3] = [__v_3, __v_0, __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 __v_8: G = G::from_u64(1);
-    let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { 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_9: G = __r_arr[0];
-    let __v_10: G = (__v_8 + __v_9);
-    let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_7, __v_1, __v_2, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[694].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_694] = unsafe { *(result.output.as_ptr() as *const [G; OUT_694]) }; __ret } else { aiur_fn_694(__args, record, io_buffer, __cu)? } };
-    let __v_11: G = __r_arr[0];
-    let __ret: [G; OUT_693] = [__v_11];
-    record.function_queries[693].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    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 __r_arr: [G; OUT_622] = { let __args: [G; IN_622] = [__v_0, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[622].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_622] = unsafe { *(result.output.as_ptr() as *const [G; OUT_622]) }; __ret } else { aiur_fn_622(__args, record, io_buffer, __cu)? } };
+    let __v_7: G = __r_arr[0];
+    let __ret: [G; OUT_621] = [__v_7];
+    record.function_queries[621].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_694: usize = 4;
-const IN_694: usize = 4;
-const OUT_694: usize = 1;
-fn aiur_fn_694(
-  inp: [G; IN_694],
+const INPUT_SIZE_622: usize = 8;
+const IN_622: usize = 8;
+const OUT_622: usize = 1;
+fn aiur_fn_622(
+  inp: [G; IN_622],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_622], 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; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; 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: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].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];
+    match __v_8.as_canonical_u64() {
+      1u64 => {
+        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 __ret: [G; OUT_622] = [__v_16];
+        record.function_queries[622].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[258].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_258] = unsafe { *(result.output.as_ptr() as *const [G; OUT_258]) }; __ret } else { aiur_fn_258(__args, record, io_buffer, __cu)? } };
+        let __v_14: G = __r_arr[0];
+        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+        let __v_15: G = __loaded[0];
+        let __v_16: G = __loaded[1];
+        let __v_17: G = __loaded[2];
+        let __v_18: G = __loaded[3];
+        let __v_19: G = __loaded[4];
+        let __v_20: G = __loaded[5];
+        let __v_21: G = __loaded[6];
+        let __v_22: G = __loaded[7];
+        let __v_23: G = __loaded[8];
+        let __v_24: G = __loaded[9];
+        let __v_25: G = __loaded[10];
+        let __v_26: G = __loaded[11];
+        match __v_15.as_canonical_u64() {
+          5u64 => {
+            let __v_27: G = G::from_u64(0);
+            let __r_arr: [G; OUT_620] = { let __args: [G; IN_620] = [__v_9, __v_10, __v_11, __v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_7, __v_22, __v_23, __v_20, __v_6, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[620].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_620] = unsafe { *(result.output.as_ptr() as *const [G; OUT_620]) }; __ret } else { aiur_fn_620(__args, record, io_buffer, __cu)? } };
+            let __v_28: G = __r_arr[0];
+            let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } else { aiur_fn_711(__args, record, io_buffer, __cu)? } };
+            let __v_29: G = __r_arr[0];
+            let __v_30: G = (__v_6 + __v_29);
+            let __v_31: G = G::from_u64(1);
+            let __v_32: G = (__v_7 + __v_31);
+            let __r_arr: [G; OUT_622] = { let __args: [G; IN_622] = [__v_13, __v_1, __v_2, __v_3, __v_4, __v_5, __v_30, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[622].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_622] = unsafe { *(result.output.as_ptr() as *const [G; OUT_622]) }; __ret } else { aiur_fn_622(__args, record, io_buffer, __cu)? } };
+            let __v_33: G = __r_arr[0];
+            let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_28, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[710].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_710] = unsafe { *(result.output.as_ptr() as *const [G; OUT_710]) }; __ret } else { aiur_fn_710(__args, record, io_buffer, __cu)? } };
+            let __v_34: G = __r_arr[0];
+            let __ret: [G; OUT_622] = [__v_34];
+            record.function_queries[622].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            let __v_27: G = G::from_u64(1);
+            let __v_28: G = (__v_7 + __v_27);
+            let __r_arr: [G; OUT_622] = { let __args: [G; IN_622] = [__v_13, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[622].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_622] = unsafe { *(result.output.as_ptr() as *const [G; OUT_622]) }; __ret } else { aiur_fn_622(__args, record, io_buffer, __cu)? } };
+            let __v_29: G = __r_arr[0];
+            let __ret: [G; OUT_622] = [__v_29];
+            record.function_queries[622].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_623: usize = 5;
+const IN_623: usize = 5;
+const OUT_623: usize = 1;
+fn aiur_fn_623(
+  inp: [G; IN_623],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_694], ExecError> {
+) -> Result<[G; OUT_623], 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 __ret: [G; OUT_694] = [__v_0];
-        record.function_queries[694].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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 __v_8: G = (__v_7 - __v_0);
+        let __v_9: G = G::from_u64(0);
+        let __v_10: G = { let __values: [G; 4] = [__v_5, __v_8, __v_9, __v_9]; 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_623] = [__v_10];
+        record.function_queries[623].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } else { aiur_fn_695(__args, record, io_buffer, __cu)? } };
-        let __v_4: G = __r_arr[0];
-        let __r_arr: [G; OUT_700] = { let __args: [G; IN_700] = [__v_0, __v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[700].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_700] = unsafe { *(result.output.as_ptr() as *const [G; OUT_700]) }; __ret } else { aiur_fn_700(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } else { aiur_fn_711(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[706].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_706] = unsafe { *(result.output.as_ptr() as *const [G; OUT_706]) }; __ret } else { aiur_fn_706(__args, record, io_buffer, __cu)? } };
-        let __v_6: G = __r_arr[0];
+        let __v_6: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_5.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_6.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_694] = [__v_0];
-            record.function_queries[694].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_4, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } };
+            let __v_7: G = __r_arr[0];
+            let __v_8: G = G::from_u64(0);
+            let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_7, __v_2, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[325].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_325] = unsafe { *(result.output.as_ptr() as *const [G; OUT_325]) }; __ret } else { aiur_fn_325(__args, record, io_buffer, __cu)? } };
+            let __v_9: G = __r_arr[0];
+            let __ret: [G; OUT_623] = [__v_9];
+            record.function_queries[623].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __v_7: G = G::from_u64(1);
-            let __v_8: G = (__v_3 - __v_7);
-            let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_5, __v_1, __v_2, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[694].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_694] = unsafe { *(result.output.as_ptr() as *const [G; OUT_694]) }; __ret } else { aiur_fn_694(__args, record, io_buffer, __cu)? } };
-            let __v_9: G = __r_arr[0];
-            let __ret: [G; OUT_694] = [__v_9];
-            record.function_queries[694].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __v_7: G = G::from_u64(0);
+            let __v_8: G = G::from_u64(1);
+            let __v_9: G = (__v_1 - __v_8);
+            let __v_10: G = (__v_9 - __v_0);
+            let __v_11: G = G::from_u64(0);
+            let __v_12: G = { let __values: [G; 4] = [__v_7, __v_10, __v_11, __v_11]; 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_623] = [__v_12];
+            record.function_queries[623].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -58425,210 +51413,291 @@ fn aiur_fn_694(
   })
 }
 
-const INPUT_SIZE_695: usize = 2;
-const IN_695: usize = 2;
-const OUT_695: usize = 1;
-fn aiur_fn_695(
-  inp: [G; IN_695],
+const INPUT_SIZE_624: usize = 2;
+const IN_624: usize = 2;
+const OUT_624: usize = 1;
+fn aiur_fn_624(
+  inp: [G; IN_624],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_695], ExecError> {
+) -> Result<[G; OUT_624], 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(0);
-    let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { 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_3: G = __r_arr[0];
-    let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } else { aiur_fn_696(__args, record, io_buffer, __cu)? } };
-    let __v_4: G = __r_arr[0];
-    let __ret: [G; OUT_695] = [__v_4];
-    record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
+    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() {
+      5u64 => {
+        let __v_6: G = G::from_u64(1);
+        let __v_7: G = (__v_1 + __v_6);
+        let __r_arr: [G; OUT_624] = { let __args: [G; IN_624] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[624].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_624] = unsafe { *(result.output.as_ptr() as *const [G; OUT_624]) }; __ret } else { aiur_fn_624(__args, record, io_buffer, __cu)? } };
+        let __v_8: G = __r_arr[0];
+        let __ret: [G; OUT_624] = [__v_8];
+        record.function_queries[624].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __ret: [G; OUT_624] = [__v_1];
+        record.function_queries[624].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+    }
   })
 }
 
-const INPUT_SIZE_696: usize = 4;
-const IN_696: usize = 4;
-const OUT_696: usize = 1;
-fn aiur_fn_696(
-  inp: [G; IN_696],
+const INPUT_SIZE_625: usize = 7;
+const IN_625: usize = 7;
+const OUT_625: usize = 1;
+fn aiur_fn_625(
+  inp: [G; IN_625],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_696], ExecError> {
+) -> Result<[G; OUT_625], 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_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_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_696] = [__v_9];
-        record.function_queries[696].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    match __v_1.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[697].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_697] = unsafe { *(result.output.as_ptr() as *const [G; OUT_697]) }; __ret } else { aiur_fn_697(__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(1);
-        let __v_10: G = (__v_2 + __v_9);
-        let __v_11: G = (__v_3 + __v_8);
-        let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_6, __v_1, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } else { aiur_fn_696(__args, record, io_buffer, __cu)? } };
-        let __v_12: G = __r_arr[0];
-        let __r_arr: [G; OUT_787] = { let __args: [G; IN_787] = [__v_7, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[787].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_787] = unsafe { *(result.output.as_ptr() as *const [G; OUT_787]) }; __ret } else { aiur_fn_787(__args, record, io_buffer, __cu)? } };
-        let __v_13: G = __r_arr[0];
-        let __ret: [G; OUT_696] = [__v_13];
-        record.function_queries[696].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_625] = [__v_0];
+        record.function_queries[625].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
+        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_7: G = __loaded[0];
+        let __v_8: G = __loaded[1];
+        let __v_9: G = __loaded[2];
+        let __v_10: G = __loaded[3];
+        match __v_7.as_canonical_u64() {
+          5u64 => {
+            let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_6, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[623].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_623] = unsafe { *(result.output.as_ptr() as *const [G; OUT_623]) }; __ret } else { aiur_fn_623(__args, record, io_buffer, __cu)? } };
+            let __v_11: G = __r_arr[0];
+            let __v_12: G = G::from_u64(0);
+            let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_9, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[331].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_331] = unsafe { *(result.output.as_ptr() as *const [G; OUT_331]) }; __ret } else { aiur_fn_331(__args, record, io_buffer, __cu)? } };
+            let __v_13: G = __r_arr[0];
+            let __v_14: G = G::from_u64(1);
+            let __v_15: G = (__v_1 - __v_14);
+            let __v_16: G = G::from_u64(1);
+            let __v_17: G = (__v_6 + __v_16);
+            let __r_arr: [G; OUT_625] = { let __args: [G; IN_625] = [__v_13, __v_15, __v_2, __v_3, __v_4, __v_5, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[625].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_625] = unsafe { *(result.output.as_ptr() as *const [G; OUT_625]) }; __ret } else { aiur_fn_625(__args, record, io_buffer, __cu)? } };
+            let __v_18: G = __r_arr[0];
+            let __ret: [G; OUT_625] = [__v_18];
+            record.function_queries[625].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            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_377] = { let __args: [G; IN_377] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = unsafe { *(result.output.as_ptr() as *const [G; OUT_377]) }; __ret } else { aiur_fn_377(__args, record, io_buffer, __cu)? } };
+            let __v_14: 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_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).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_15: G = __loaded[0];
+            let __v_16: G = __loaded[1];
+            let __v_17: G = __loaded[2];
+            let __v_18: G = __loaded[3];
+            match __v_15.as_canonical_u64() {
+              5u64 => {
+                let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_6, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[623].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_623] = unsafe { *(result.output.as_ptr() as *const [G; OUT_623]) }; __ret } else { aiur_fn_623(__args, record, io_buffer, __cu)? } };
+                let __v_19: G = __r_arr[0];
+                let __v_20: G = G::from_u64(0);
+                let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_17, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[331].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_331] = unsafe { *(result.output.as_ptr() as *const [G; OUT_331]) }; __ret } else { aiur_fn_331(__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_1 - __v_22);
+                let __v_24: G = G::from_u64(1);
+                let __v_25: G = (__v_6 + __v_24);
+                let __r_arr: [G; OUT_625] = { let __args: [G; IN_625] = [__v_21, __v_23, __v_2, __v_3, __v_4, __v_5, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[625].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_625] = unsafe { *(result.output.as_ptr() as *const [G; OUT_625]) }; __ret } else { aiur_fn_625(__args, record, io_buffer, __cu)? } };
+                let __v_26: G = __r_arr[0];
+                let __ret: [G; OUT_625] = [__v_26];
+                record.function_queries[625].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+              _ => {
+                return Err(ExecError::MatchNoCase(__v_15.as_canonical_u64()));
+              },
+            }
+          },
+        }
       },
     }
   })
 }
 
-const INPUT_SIZE_697: usize = 4;
-const IN_697: usize = 4;
-const OUT_697: usize = 2;
-fn aiur_fn_697(
-  inp: [G; IN_697],
+const INPUT_SIZE_626: usize = 13;
+const IN_626: usize = 13;
+const OUT_626: usize = 1;
+fn aiur_fn_626(
+  inp: [G; IN_626],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_697], ExecError> {
+) -> Result<[G; OUT_626], 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_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_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 __v_10: G = G::from_u64(0);
-        let __ret: [G; OUT_697] = [__v_9, __v_10];
-        record.function_queries[697].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[697].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_697] = unsafe { *(result.output.as_ptr() as *const [G; OUT_697]) }; __ret } else { aiur_fn_697(__args, record, io_buffer, __cu)? } };
-        let __v_7: G = __r_arr[0];
-        let __v_8: G = __r_arr[1];
-        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-        let __v_9: G = __r_arr[0];
-        let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].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 __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } else { aiur_fn_699(__args, record, io_buffer, __cu)? } };
-        let __v_21: G = __r_arr[0];
-        let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { 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_22: G = __r_arr[0];
-        let __v_23: G = G::from_u64(0);
-        let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_21, __v_3, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[698].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_698] = unsafe { *(result.output.as_ptr() as *const [G; OUT_698]) }; __ret } else { aiur_fn_698(__args, record, io_buffer, __cu)? } };
-        let __v_24: G = __r_arr[0];
-        let __v_25: G = G::from_u64(0);
-        let __r_arr: [G; OUT_787] = { let __args: [G; IN_787] = [__v_24, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[787].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_787] = unsafe { *(result.output.as_ptr() as *const [G; OUT_787]) }; __ret } else { aiur_fn_787(__args, record, io_buffer, __cu)? } };
-        let __v_26: G = __r_arr[0];
-        let __v_27: G = { let __values: [G; 4] = [__v_25, __v_5, __v_2, __v_26]; 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_28: G = { let __a_val = __v_8.as_canonical_u64(); let __b_val = __v_22.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_28.as_canonical_u64() {
-          1u64 => {
-            let __ret: [G; OUT_697] = [__v_27, __v_22];
-            record.function_queries[697].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            let __ret: [G; OUT_697] = [__v_27, __v_8];
-            record.function_queries[697].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-        }
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
-      },
-    }
+    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 __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } else { aiur_fn_307(__args, record, io_buffer, __cu)? } };
+    let __v_13: G = __r_arr[0];
+    let __v_14: G = (__v_9 + __v_10);
+    let __v_15: G = (__v_8 + __v_14);
+    let __v_16: G = (__v_9 + __v_10);
+    let __v_17: G = G::from_u64(0);
+    let __r_arr: [G; OUT_625] = { let __args: [G; IN_625] = [__v_13, __v_2, __v_15, __v_16, __v_3, __v_4, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[625].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_625] = unsafe { *(result.output.as_ptr() as *const [G; OUT_625]) }; __ret } else { aiur_fn_625(__args, record, io_buffer, __cu)? } };
+    let __v_18: G = __r_arr[0];
+    let __v_19: G = G::from_u64(1);
+    let __v_20: G = G::from_u64(1);
+    let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __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 = G::from_u64(1);
+    let __v_23: G = G::from_u64(1);
+    let __v_24: G = { let __values: [G; 3] = [__v_22, __v_23, __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 __v_25: G = G::from_u64(1);
+    let __v_26: G = G::from_u64(1);
+    let __v_27: G = { let __values: [G; 3] = [__v_25, __v_26, __v_26]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_28: G = G::from_u64(0);
+    let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = [__v_18, __v_6, __v_21, __v_24, __v_27, __v_28, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[637].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_637] = unsafe { *(result.output.as_ptr() as *const [G; OUT_637]) }; __ret } else { aiur_fn_637(__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 __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } else { aiur_fn_711(__args, record, io_buffer, __cu)? } };
+    let __v_33: G = __r_arr[0];
+    let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } else { aiur_fn_711(__args, record, io_buffer, __cu)? } };
+    let __v_34: G = __r_arr[0];
+    let __v_35: G = (__v_33 + __v_34);
+    let __v_36: G = (__v_15 + __v_35);
+    let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[106].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_106] = unsafe { *(result.output.as_ptr() as *const [G; OUT_106]) }; __ret } else { aiur_fn_106(__args, record, io_buffer, __cu)? } };
+    let __v_37: G = __r_arr[0];
+    let __v_38: G = __r_arr[1];
+    let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_38, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } };
+    let __v_39: G = __r_arr[0];
+    let __v_40: G = G::from_u64(0);
+    let __r_arr: [G; OUT_630] = { let __args: [G; IN_630] = [__v_39, __v_34, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[630].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_630] = unsafe { *(result.output.as_ptr() as *const [G; OUT_630]) }; __ret } else { aiur_fn_630(__args, record, io_buffer, __cu)? } };
+    let __v_41: G = __r_arr[0];
+    let __v_42: G = G::from_u64(1);
+    let __v_43: G = (__v_36 - __v_42);
+    let __v_44: G = (__v_11 + __v_12);
+    let __v_45: G = (__v_43 - __v_44);
+    let __v_46: G = G::from_u64(0);
+    let __v_47: G = G::from_u64(0);
+    let __v_48: G = { let __values: [G; 4] = [__v_46, __v_45, __v_47, __v_47]; 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_228] = { let __args: [G; IN_228] = [__v_48, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } };
+    let __v_49: G = __r_arr[0];
+    let __v_50: G = G::from_u64(2);
+    let __v_51: G = G::from_u64(0);
+    let __v_52: G = { let __values: [G; 4] = [__v_50, __v_0, __v_5, __v_51]; 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_632] = { let __args: [G; IN_632] = [__v_52, __v_2, __v_8, __v_36, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[632].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_632] = unsafe { *(result.output.as_ptr() as *const [G; OUT_632]) }; __ret } else { aiur_fn_632(__args, record, io_buffer, __cu)? } };
+    let __v_53: G = __r_arr[0];
+    let __v_54: G = G::from_u64(0);
+    let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_53, __v_33, __v_35, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[631].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_631] = unsafe { *(result.output.as_ptr() as *const [G; OUT_631]) }; __ret } else { aiur_fn_631(__args, record, io_buffer, __cu)? } };
+    let __v_55: G = __r_arr[0];
+    let __v_56: G = G::from_u64(3);
+    let __v_57: G = G::from_u64(0);
+    let __v_58: G = { let __values: [G; 4] = [__v_56, __v_49, __v_55, __v_57]; 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_59: G = G::from_u64(0);
+    let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_30, __v_31, __v_29, __v_7, __v_11, __v_33, __v_15, __v_59]; let __cu = unconstrained; if let Some(result) = record.function_queries[629].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_629] = unsafe { *(result.output.as_ptr() as *const [G; OUT_629]) }; __ret } else { aiur_fn_629(__args, record, io_buffer, __cu)? } };
+    let __v_60: G = __r_arr[0];
+    let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = [__v_58, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[597].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_597] = unsafe { *(result.output.as_ptr() as *const [G; OUT_597]) }; __ret } else { aiur_fn_597(__args, record, io_buffer, __cu)? } };
+    let __v_61: G = __r_arr[0];
+    let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = [__v_61, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[597].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_597] = unsafe { *(result.output.as_ptr() as *const [G; OUT_597]) }; __ret } else { aiur_fn_597(__args, record, io_buffer, __cu)? } };
+    let __v_62: G = __r_arr[0];
+    let __ret: [G; OUT_626] = [__v_62];
+    record.function_queries[626].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_698: usize = 3;
-const IN_698: usize = 3;
-const OUT_698: usize = 1;
-fn aiur_fn_698(
-  inp: [G; IN_698],
+const INPUT_SIZE_627: usize = 1;
+const IN_627: usize = 1;
+const OUT_627: usize = 2;
+fn aiur_fn_627(
+  inp: [G; IN_627],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_698], ExecError> {
+) -> Result<[G; OUT_627], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = G::from_u64(1);
+    let __v_2: G = G::from_u64(1);
+    let __v_3: G = { let __values: [G; 3] = [__v_1, __v_2, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_628] = { let __args: [G; IN_628] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[628].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_628] = unsafe { *(result.output.as_ptr() as *const [G; OUT_628]) }; __ret } else { aiur_fn_628(__args, record, io_buffer, __cu)? } };
+    let __v_4: G = __r_arr[0];
+    let __v_5: G = __r_arr[1];
+    let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[709].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_709] = unsafe { *(result.output.as_ptr() as *const [G; OUT_709]) }; __ret } else { aiur_fn_709(__args, record, io_buffer, __cu)? } };
+    let __v_6: G = __r_arr[0];
+    let __ret: [G; OUT_627] = [__v_6, __v_5];
+    record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_628: usize = 2;
+const IN_628: usize = 2;
+const OUT_628: usize = 2;
+fn aiur_fn_628(
+  inp: [G; IN_628],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_628], 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; 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_698] = [__v_8];
-        record.function_queries[698].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_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() {
+      5u64 => {
         let __v_6: G = G::from_u64(0);
-        let __v_7: G = (__v_1 + __v_2);
-        let __v_8: G = G::from_u64(1);
-        let __v_9: G = (__v_2 + __v_8);
-        let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_5, __v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[698].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_698] = unsafe { *(result.output.as_ptr() as *const [G; OUT_698]) }; __ret } else { aiur_fn_698(__args, record, io_buffer, __cu)? } };
-        let __v_10: G = __r_arr[0];
-        let __v_11: G = { let __values: [G; 4] = [__v_6, __v_4, __v_7, __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_698] = [__v_11];
-        record.function_queries[698].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __v_7: G = { let __values: [G; 3] = [__v_6, __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_628] = { let __args: [G; IN_628] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[628].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_628] = unsafe { *(result.output.as_ptr() as *const [G; OUT_628]) }; __ret } else { aiur_fn_628(__args, record, io_buffer, __cu)? } };
+        let __v_8: G = __r_arr[0];
+        let __v_9: G = __r_arr[1];
+        let __ret: [G; OUT_628] = [__v_8, __v_9];
+        record.function_queries[628].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
+        let __ret: [G; OUT_628] = [__v_1, __v_0];
+        record.function_queries[628].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_699: usize = 11;
-const IN_699: usize = 11;
-const OUT_699: usize = 1;
-fn aiur_fn_699(
-  inp: [G; IN_699],
+const INPUT_SIZE_629: usize = 8;
+const IN_629: usize = 8;
+const OUT_629: usize = 1;
+fn aiur_fn_629(
+  inp: [G; IN_629],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_699], ExecError> {
+) -> Result<[G; OUT_629], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -58638,482 +51707,456 @@ fn aiur_fn_699(
     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];
-    match __v_0.as_canonical_u64() {
-      5u64 => {
-        let __ret: [G; OUT_699] = [__v_5];
-        record.function_queries[699].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_8: G = __loaded[0];
+    let __v_9: G = __loaded[1];
+    let __v_10: G = __loaded[2];
+    match __v_8.as_canonical_u64() {
+      1u64 => {
         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 __ret: [G; OUT_699] = [__v_13];
-        record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_629] = [__v_13];
+        record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __v_11: G = G::from_u64(0);
+        let __r_arr: [G; OUT_703] = { let __args: [G; IN_703] = [__v_1, __v_7, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[703].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_703] = unsafe { *(result.output.as_ptr() as *const [G; OUT_703]) }; __ret } else { aiur_fn_703(__args, record, io_buffer, __cu)? } };
+        let __v_12: G = __r_arr[0];
+        let __v_13: G = G::from_u64(0);
+        let __r_arr: [G; OUT_703] = { let __args: [G; IN_703] = [__v_3, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[703].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_703] = unsafe { *(result.output.as_ptr() as *const [G; OUT_703]) }; __ret } else { aiur_fn_703(__args, record, io_buffer, __cu)? } };
+        let __v_14: G = __r_arr[0];
+        let __v_15: G = (__v_5 + __v_7);
+        let __v_16: G = (__v_6 + __v_15);
+        let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } };
+        let __v_17: G = __r_arr[0];
+        let __v_18: G = (__v_5 - __v_9);
+        let __v_19: G = (__v_18 + __v_7);
+        let __v_20: G = G::from_u64(0);
+        let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_17, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[325].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_325] = unsafe { *(result.output.as_ptr() as *const [G; OUT_325]) }; __ret } else { aiur_fn_325(__args, record, io_buffer, __cu)? } };
+        let __v_21: G = __r_arr[0];
+        let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } else { aiur_fn_627(__args, record, io_buffer, __cu)? } };
+        let __v_22: G = __r_arr[0];
+        let __v_23: G = __r_arr[1];
+        let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } else { aiur_fn_711(__args, record, io_buffer, __cu)? } };
+        let __v_24: G = __r_arr[0];
+        let __v_25: G = (__v_16 + __v_24);
+        let __v_26: G = G::from_u64(1);
+        let __v_27: G = (__v_25 - __v_26);
+        let __v_28: G = (__v_4 + __v_12);
+        let __v_29: G = (__v_27 - __v_28);
+        let __v_30: G = G::from_u64(1);
+        let __v_31: G = (__v_25 - __v_30);
+        let __v_32: G = (__v_6 + __v_9);
+        let __v_33: G = (__v_31 - __v_32);
+        let __v_34: G = G::from_u64(1);
+        let __v_35: G = G::from_u64(1);
+        let __v_36: G = { let __values: [G; 3] = [__v_34, __v_35, __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 __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_23, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = unsafe { *(result.output.as_ptr() as *const [G; OUT_377]) }; __ret } else { aiur_fn_377(__args, record, io_buffer, __cu)? } };
+        let __v_37: G = __r_arr[0];
+        let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[106].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_106] = unsafe { *(result.output.as_ptr() as *const [G; OUT_106]) }; __ret } else { aiur_fn_106(__args, record, io_buffer, __cu)? } };
+        let __v_38: G = __r_arr[0];
+        let __v_39: G = __r_arr[1];
+        let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_39, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } };
+        let __v_40: G = __r_arr[0];
+        let __v_41: G = G::from_u64(0);
+        let __v_42: G = G::from_u64(0);
+        let __v_43: G = { let __values: [G; 4] = [__v_41, __v_29, __v_42, __v_42]; 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_228] = { let __args: [G; IN_228] = [__v_43, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__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(0);
+        let __v_47: G = { let __values: [G; 4] = [__v_45, __v_33, __v_46, __v_46]; 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_48: G = G::from_u64(0);
+        let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_47, __v_24, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } else { aiur_fn_596(__args, record, io_buffer, __cu)? } };
+        let __v_49: G = __r_arr[0];
+        let __v_50: G = G::from_u64(3);
+        let __v_51: G = G::from_u64(0);
+        let __v_52: G = { let __values: [G; 4] = [__v_50, __v_44, __v_49, __v_51]; 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_597] = { let __args: [G; IN_597] = [__v_52, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[597].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_597] = unsafe { *(result.output.as_ptr() as *const [G; OUT_597]) }; __ret } else { aiur_fn_597(__args, record, io_buffer, __cu)? } };
+        let __v_53: G = __r_arr[0];
+        let __v_54: G = G::from_u64(0);
+        let __v_55: G = G::from_u64(1);
+        let __v_56: G = (__v_7 + __v_55);
+        let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_10, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[629].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_629] = unsafe { *(result.output.as_ptr() as *const [G; OUT_629]) }; __ret } else { aiur_fn_629(__args, record, io_buffer, __cu)? } };
+        let __v_57: G = __r_arr[0];
+        let __v_58: G = { let __values: [G; 3] = [__v_54, __v_53, __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 __ret: [G; OUT_629] = [__v_58];
+        record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64()));
+      },
     }
   })
 }
 
-const INPUT_SIZE_700: usize = 4;
-const IN_700: usize = 4;
-const OUT_700: usize = 1;
-fn aiur_fn_700(
-  inp: [G; IN_700],
+const INPUT_SIZE_630: usize = 3;
+const IN_630: usize = 3;
+const OUT_630: usize = 1;
+fn aiur_fn_630(
+  inp: [G; IN_630],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_700], ExecError> {
+) -> Result<[G; OUT_630], 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_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_4: G = __loaded[0];
-    let __v_5: G = __loaded[1];
-    let __v_6: G = __loaded[2];
-    match __v_4.as_canonical_u64() {
+    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 = G::from_u64(1);
-        let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __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_700] = [__v_9];
-        record.function_queries[700].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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_630] = [__v_8];
+        record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_701] = { let __args: [G; IN_701] = [__v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[701].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_701] = unsafe { *(result.output.as_ptr() as *const [G; OUT_701]) }; __ret } else { aiur_fn_701(__args, record, io_buffer, __cu)? } };
+        let __v_6: G = G::from_u64(0);
+        let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[325].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_325] = unsafe { *(result.output.as_ptr() as *const [G; OUT_325]) }; __ret } else { aiur_fn_325(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_700] = { let __args: [G; IN_700] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[700].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_700] = unsafe { *(result.output.as_ptr() as *const [G; OUT_700]) }; __ret } else { aiur_fn_700(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_630] = { let __args: [G; IN_630] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[630].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_630] = unsafe { *(result.output.as_ptr() as *const [G; OUT_630]) }; __ret } else { aiur_fn_630(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_773] = { let __args: [G; IN_773] = [__v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[773].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_773] = unsafe { *(result.output.as_ptr() as *const [G; OUT_773]) }; __ret } else { aiur_fn_773(__args, record, io_buffer, __cu)? } };
-        let __v_9: G = __r_arr[0];
-        let __ret: [G; OUT_700] = [__v_9];
-        record.function_queries[700].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __v_9: G = { let __values: [G; 3] = [__v_6, __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 __ret: [G; OUT_630] = [__v_9];
+        record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
+        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_701: usize = 4;
-const IN_701: usize = 4;
-const OUT_701: usize = 1;
-fn aiur_fn_701(
-  inp: [G; IN_701],
+const INPUT_SIZE_631: usize = 4;
+const IN_631: usize = 4;
+const OUT_631: usize = 1;
+fn aiur_fn_631(
+  inp: [G; IN_631],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_701], ExecError> {
+) -> Result<[G; OUT_631], 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_187] = { let __args: [G; IN_187] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { 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_4: G = __r_arr[0];
+    let __v_4: G = (__v_1 - __v_3);
     match __v_4.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_701] = [__v_7];
-        record.function_queries[701].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_631] = [__v_0];
+        record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      1u64 => {
+      _ => {
         let __v_5: G = G::from_u64(0);
         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 __v_9: G = { let __values: [G; 3] = [__v_5, __v_0, __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_701] = [__v_9];
-        record.function_queries[701].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[702].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_702] = unsafe { *(result.output.as_ptr() as *const [G; OUT_702]) }; __ret } else { aiur_fn_702(__args, record, io_buffer, __cu)? } };
-        let __v_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_704] = { let __args: [G; IN_704] = [__v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[704].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_704] = unsafe { *(result.output.as_ptr() as *const [G; OUT_704]) }; __ret } else { aiur_fn_704(__args, record, io_buffer, __cu)? } };
-        let __v_6: G = __r_arr[0];
-        let __ret: [G; OUT_701] = [__v_6];
-        record.function_queries[701].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __v_7: G = (__v_2 - __v_6);
+        let __v_8: G = (__v_7 - __v_3);
+        let __v_9: G = G::from_u64(0);
+        let __v_10: G = { let __values: [G; 4] = [__v_5, __v_8, __v_9, __v_9]; 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_11: G = G::from_u64(3);
+        let __v_12: G = G::from_u64(0);
+        let __v_13: G = { let __values: [G; 4] = [__v_11, __v_0, __v_10, __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 __v_14: G = G::from_u64(1);
+        let __v_15: G = (__v_3 + __v_14);
+        let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_13, __v_1, __v_2, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[631].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_631] = unsafe { *(result.output.as_ptr() as *const [G; OUT_631]) }; __ret } else { aiur_fn_631(__args, record, io_buffer, __cu)? } };
+        let __v_16: G = __r_arr[0];
+        let __ret: [G; OUT_631] = [__v_16];
+        record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_702: usize = 4;
-const IN_702: usize = 4;
-const OUT_702: usize = 1;
-fn aiur_fn_702(
-  inp: [G; IN_702],
+const INPUT_SIZE_632: usize = 6;
+const IN_632: usize = 6;
+const OUT_632: usize = 1;
+fn aiur_fn_632(
+  inp: [G; IN_632],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_702], ExecError> {
+) -> Result<[G; OUT_632], 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_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_4: G = __loaded[0];
-    let __v_5: G = __loaded[1];
-    let __v_6: G = __loaded[2];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
     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; 3] = [__v_7, __v_8, __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_702] = [__v_9];
-        record.function_queries[702].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
       0u64 => {
-        let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[702].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_702] = unsafe { *(result.output.as_ptr() as *const [G; OUT_702]) }; __ret } else { aiur_fn_702(__args, record, io_buffer, __cu)? } };
-        let __v_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_703] = { let __args: [G; IN_703] = [__v_5, __v_7, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[703].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_703] = unsafe { *(result.output.as_ptr() as *const [G; OUT_703]) }; __ret } else { aiur_fn_703(__args, record, io_buffer, __cu)? } };
-        let __v_8: G = __r_arr[0];
-        let __ret: [G; OUT_702] = [__v_8];
-        record.function_queries[702].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __v_6: G = G::from_u64(1);
+        let __v_7: G = (__v_3 - __v_6);
+        let __v_8: G = G::from_u64(0);
+        let __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_0, __v_2, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[604].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_604] = unsafe { *(result.output.as_ptr() as *const [G; OUT_604]) }; __ret } else { aiur_fn_604(__args, record, io_buffer, __cu)? } };
+        let __v_9: G = __r_arr[0];
+        let __ret: [G; OUT_632] = [__v_9];
+        record.function_queries[632].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
+        let __v_6: G = (__v_3 - __v_2);
+        let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = [__v_0, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[594].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_594] = unsafe { *(result.output.as_ptr() as *const [G; OUT_594]) }; __ret } else { aiur_fn_594(__args, record, io_buffer, __cu)? } };
+        let __v_7: G = __r_arr[0];
+        let __ret: [G; OUT_632] = [__v_7];
+        record.function_queries[632].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_703: usize = 5;
-const IN_703: usize = 5;
-const OUT_703: usize = 1;
-fn aiur_fn_703(
-  inp: [G; IN_703],
+const INPUT_SIZE_633: usize = 3;
+const IN_633: usize = 3;
+const OUT_633: usize = 2;
+fn aiur_fn_633(
+  inp: [G; IN_633],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_703], ExecError> {
+) -> Result<[G; OUT_633], 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 __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_5: G = __loaded[0];
-    let __v_6: G = __loaded[1];
-    let __v_7: G = __loaded[2];
-    match __v_5.as_canonical_u64() {
-      1u64 => {
-        let __v_8: G = G::from_u64(0);
-        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 __v_12: G = { let __values: [G; 3] = [__v_8, __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_703] = [__v_12];
-        record.function_queries[703].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_3, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-        let __v_8: G = __r_arr[0];
-        let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].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 __v_17: G = __loaded[8];
-        let __v_18: G = __loaded[9];
-        let __v_19: G = __loaded[10];
-        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-        let __v_20: G = __r_arr[0];
-        let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_20.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr };
-        let __v_21: G = __loaded[0];
-        let __v_22: G = __loaded[1];
-        let __v_23: G = __loaded[2];
-        let __v_24: G = __loaded[3];
-        let __v_25: G = __loaded[4];
-        let __v_26: G = __loaded[5];
-        let __v_27: G = __loaded[6];
-        let __v_28: G = __loaded[7];
-        let __v_29: G = __loaded[8];
-        let __v_30: G = __loaded[9];
-        let __v_31: G = __loaded[10];
-        let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = unsafe { *(result.output.as_ptr() as *const [G; OUT_680]) }; __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } };
-        let __v_32: G = __r_arr[0];
-        let __v_33: G = __r_arr[1];
-        match __v_32.as_canonical_u64() {
-          0u64 => {
-            let __v_34: G = G::from_u64(0);
-            let __v_35: G = { let __values: [G; 3] = [__v_34, __v_0, __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_703] = [__v_35];
-            record.function_queries[703].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            let __v_34: G = G::from_u64(0);
-            let __r_arr: [G; OUT_703] = { let __args: [G; IN_703] = [__v_0, __v_7, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[703].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_703] = unsafe { *(result.output.as_ptr() as *const [G; OUT_703]) }; __ret } else { aiur_fn_703(__args, record, io_buffer, __cu)? } };
-            let __v_35: G = __r_arr[0];
-            let __v_36: G = { let __values: [G; 3] = [__v_34, __v_6, __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 __ret: [G; OUT_703] = [__v_36];
-            record.function_queries[703].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-        }
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
-      },
-    }
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[634].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_634] = unsafe { *(result.output.as_ptr() as *const [G; OUT_634]) }; __ret } else { aiur_fn_634(__args, record, io_buffer, __cu)? } };
+    let __v_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __ret: [G; OUT_633] = [__v_3, __v_4];
+    record.function_queries[633].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_704: usize = 4;
-const IN_704: usize = 4;
-const OUT_704: usize = 1;
-fn aiur_fn_704(
-  inp: [G; IN_704],
+const INPUT_SIZE_634: usize = 3;
+const IN_634: usize = 3;
+const OUT_634: usize = 2;
+fn aiur_fn_634(
+  inp: [G; IN_634],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_704], ExecError> {
+) -> Result<[G; OUT_634], 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_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_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; 3] = [__v_7, __v_8, __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_704] = [__v_9];
-        record.function_queries[704].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __v_7: G = G::from_u64(0);
-        let __v_8: G = G::from_u64(1);
-        let __v_9: G = G::from_u64(1);
-        let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __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_7, __v_5, __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_705] = { let __args: [G; IN_705] = [__v_6, __v_1, __v_2, __v_3, __v_5, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[705].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_705] = unsafe { *(result.output.as_ptr() as *const [G; OUT_705]) }; __ret } else { aiur_fn_705(__args, record, io_buffer, __cu)? } };
-        let __v_12: G = __r_arr[0];
-        let __ret: [G; OUT_704] = [__v_12];
-        record.function_queries[704].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __v_3: G = G::from_u64(1);
+    let __v_4: G = G::from_u64(1);
+    let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __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 __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = unsafe { *(result.output.as_ptr() as *const [G; OUT_377]) }; __ret } else { aiur_fn_377(__args, record, io_buffer, __cu)? } };
+    let __v_6: 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_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: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].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];
+    match __v_7.as_canonical_u64() {
+      5u64 => {
+        let __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_9, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[634].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_634] = unsafe { *(result.output.as_ptr() as *const [G; OUT_634]) }; __ret } else { aiur_fn_634(__args, record, io_buffer, __cu)? } };
+        let __v_11: G = __r_arr[0];
+        let __v_12: G = __r_arr[1];
+        let __ret: [G; OUT_634] = [__v_11, __v_12];
+        record.function_queries[634].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
+        let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[106].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_106] = unsafe { *(result.output.as_ptr() as *const [G; OUT_106]) }; __ret } else { aiur_fn_106(__args, record, io_buffer, __cu)? } };
+        let __v_11: G = __r_arr[0];
+        let __v_12: G = __r_arr[1];
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).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_13: G = __loaded[0];
+        let __v_14: G = __loaded[1];
+        let __v_15: G = __loaded[2];
+        let __v_16: G = __loaded[3];
+        match __v_13.as_canonical_u64() {
+          2u64 => {
+            let __v_17: G = G::from_u64(0);
+            let __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_1, __v_14, __v_12, __v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[635].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_635] = unsafe { *(result.output.as_ptr() as *const [G; OUT_635]) }; __ret } else { aiur_fn_635(__args, record, io_buffer, __cu)? } };
+            let __v_18: G = __r_arr[0];
+            let __v_19: G = __r_arr[1];
+            let __ret: [G; OUT_634] = [__v_18, __v_19];
+            record.function_queries[634].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            let __v_17: G = G::from_u64(0);
+            let __v_18: G = G::from_u64(0);
+            let __ret: [G; OUT_634] = [__v_17, __v_18];
+            record.function_queries[634].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+        }
       },
     }
   })
 }
 
-const INPUT_SIZE_705: usize = 6;
-const IN_705: usize = 6;
-const OUT_705: usize = 1;
-fn aiur_fn_705(
-  inp: [G; IN_705],
+const INPUT_SIZE_635: usize = 5;
+const IN_635: usize = 5;
+const OUT_635: usize = 2;
+fn aiur_fn_635(
+  inp: [G; IN_635],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_705], ExecError> {
+) -> Result<[G; OUT_635], 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_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_6: G = __loaded[0];
-    let __v_7: G = __loaded[1];
-    let __v_8: G = __loaded[2];
-    match __v_6.as_canonical_u64() {
+    let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; 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: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].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];
+    match __v_5.as_canonical_u64() {
       1u64 => {
-        let __v_9: G = G::from_u64(0);
-        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 __v_13: G = { let __values: [G; 3] = [__v_9, __v_5, __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 __ret: [G; OUT_705] = [__v_13];
-        record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __v_11: G = G::from_u64(0);
+        let __v_12: G = G::from_u64(0);
+        let __ret: [G; OUT_635] = [__v_11, __v_12];
+        record.function_queries[635].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-        let __v_9: G = __r_arr[0];
-        let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].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 __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-        let __v_21: G = __r_arr[0];
-        let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr };
-        let __v_22: G = __loaded[0];
-        let __v_23: G = __loaded[1];
-        let __v_24: G = __loaded[2];
-        let __v_25: G = __loaded[3];
-        let __v_26: G = __loaded[4];
-        let __v_27: G = __loaded[5];
-        let __v_28: G = __loaded[6];
-        let __v_29: G = __loaded[7];
-        let __v_30: G = __loaded[8];
-        let __v_31: G = __loaded[9];
-        let __v_32: G = __loaded[10];
-        let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = unsafe { *(result.output.as_ptr() as *const [G; OUT_680]) }; __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } };
-        let __v_33: G = __r_arr[0];
-        let __v_34: G = __r_arr[1];
-        match __v_33.as_canonical_u64() {
+        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_11: G = __r_arr[0];
+        let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_7.as_canonical_u64() {
+  0u64 => {
+    let __v_12: G = G::from_u64(1);
+    break '__mc_0 [__v_12];
+  },
+  _ => {
+    let __r_arr: [G; OUT_636] = { let __args: [G; IN_636] = [__v_8, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[636].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_636] = unsafe { *(result.output.as_ptr() as *const [G; OUT_636]) }; __ret } else { aiur_fn_636(__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 __v_13: G = (__v_11 * __v_12);
+        match __v_13.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
-            let __v_35: G = __r_arr[0];
-            let __r_arr: [G; OUT_705] = { let __args: [G; IN_705] = [__v_8, __v_1, __v_2, __v_3, __v_7, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[705].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_705] = unsafe { *(result.output.as_ptr() as *const [G; OUT_705]) }; __ret } else { aiur_fn_705(__args, record, io_buffer, __cu)? } };
-            let __v_36: G = __r_arr[0];
-            let __ret: [G; OUT_705] = [__v_36];
-            record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __v_14: G = G::from_u64(1);
+            let __ret: [G; OUT_635] = [__v_14, __v_4];
+            record.function_queries[635].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __v_35: G = G::from_u64(0);
-            let __v_36: G = G::from_u64(0);
-            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 = { let __values: [G; 3] = [__v_36, __v_7, __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 __r_arr: [G; OUT_705] = { let __args: [G; IN_705] = [__v_8, __v_1, __v_2, __v_3, __v_7, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[705].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_705] = unsafe { *(result.output.as_ptr() as *const [G; OUT_705]) }; __ret } else { aiur_fn_705(__args, record, io_buffer, __cu)? } };
-            let __v_41: G = __r_arr[0];
-            let __v_42: G = { let __values: [G; 3] = [__v_35, __v_5, __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_705] = [__v_42];
-            record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __v_14: G = G::from_u64(1);
+            let __v_15: G = (__v_4 + __v_14);
+            let __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_10, __v_1, __v_2, __v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[635].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_635] = unsafe { *(result.output.as_ptr() as *const [G; OUT_635]) }; __ret } else { aiur_fn_635(__args, record, io_buffer, __cu)? } };
+            let __v_16: G = __r_arr[0];
+            let __v_17: G = __r_arr[1];
+            let __ret: [G; OUT_635] = [__v_16, __v_17];
+            record.function_queries[635].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64()));
+        return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_706: usize = 2;
-const IN_706: usize = 2;
-const OUT_706: usize = 1;
-fn aiur_fn_706(
-  inp: [G; IN_706],
+const INPUT_SIZE_636: usize = 3;
+const IN_636: usize = 3;
+const OUT_636: usize = 1;
+fn aiur_fn_636(
+  inp: [G; IN_636],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_706], ExecError> {
+) -> Result<[G; OUT_636], 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() {
+    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 __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_5: G = __loaded[0];
-        let __v_6: G = __loaded[1];
-        let __v_7: G = __loaded[2];
-        match __v_5.as_canonical_u64() {
-          1u64 => {
-            let __v_8: G = G::from_u64(1);
-            let __ret: [G; OUT_706] = [__v_8];
-            record.function_queries[706].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_706] = [__v_8];
-            record.function_queries[706].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-        }
+        let __v_6: G = G::from_u64(1);
+        let __ret: [G; OUT_636] = [__v_6];
+        record.function_queries[636].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_5: G = __loaded[0];
-        let __v_6: G = __loaded[1];
-        let __v_7: G = __loaded[2];
-        match __v_5.as_canonical_u64() {
+        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 __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_706] = [__v_8];
-            record.function_queries[706].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __v_9: G = G::from_u64(0);
+            let __ret: [G; OUT_636] = [__v_9];
+            record.function_queries[636].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[231].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_231] = unsafe { *(result.output.as_ptr() as *const [G; OUT_231]) }; __ret } else { aiur_fn_231(__args, record, io_buffer, __cu)? } };
-            let __v_8: G = __r_arr[0];
-            match __v_8.as_canonical_u64() {
-              0u64 => {
-                let __v_9: G = G::from_u64(0);
-                let __ret: [G; OUT_706] = [__v_9];
-                record.function_queries[706].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __v_9: G = G::from_u64(0);
+            let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_4, __v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[325].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_325] = unsafe { *(result.output.as_ptr() as *const [G; OUT_325]) }; __ret } else { aiur_fn_325(__args, record, io_buffer, __cu)? } };
+            let __v_10: G = __r_arr[0];
+            let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_10, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[578].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_578] = unsafe { *(result.output.as_ptr() as *const [G; OUT_578]) }; __ret } else { aiur_fn_578(__args, record, io_buffer, __cu)? } };
+            let __v_11: G = __r_arr[0];
+            match __v_11.as_canonical_u64() {
+              1u64 => {
+                let __r_arr: [G; OUT_636] = { let __args: [G; IN_636] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[636].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_636] = unsafe { *(result.output.as_ptr() as *const [G; OUT_636]) }; __ret } else { aiur_fn_636(__args, record, io_buffer, __cu)? } };
+                let __v_12: G = __r_arr[0];
+                let __ret: [G; OUT_636] = [__v_12];
+                record.function_queries[636].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[706].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_706] = unsafe { *(result.output.as_ptr() as *const [G; OUT_706]) }; __ret } else { aiur_fn_706(__args, record, io_buffer, __cu)? } };
-                let __v_9: G = __r_arr[0];
-                let __ret: [G; OUT_706] = [__v_9];
-                record.function_queries[706].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __v_12: G = G::from_u64(0);
+                let __ret: [G; OUT_636] = [__v_12];
+                record.function_queries[636].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
           },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
+            return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64()));
           },
         }
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_707: usize = 11;
-const IN_707: usize = 11;
-const OUT_707: usize = 1;
-fn aiur_fn_707(
-  inp: [G; IN_707],
+const INPUT_SIZE_637: usize = 7;
+const IN_637: usize = 7;
+const OUT_637: usize = 4;
+fn aiur_fn_637(
+  inp: [G; IN_637],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_707], ExecError> {
+) -> Result<[G; OUT_637], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -59122,509 +52165,349 @@ fn aiur_fn_707(
     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];
-    match __v_0.as_canonical_u64() {
-      0u64 => {
-        let __ret: [G; OUT_707] = [__v_3];
-        record.function_queries[707].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      1u64 => {
-        match __v_4.as_canonical_u64() {
-          0u64 => {
-            let __v_11: G = G::from_u64(1);
-            let __ret: [G; OUT_707] = [__v_11];
-            record.function_queries[707].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_7: G = __loaded[0];
+    let __v_8: G = __loaded[1];
+    let __v_9: G = __loaded[2];
+    let __v_10: G = __loaded[3];
+    match __v_7.as_canonical_u64() {
+      5u64 => {
+        let __v_11: G = (__v_6 + __v_5);
+        let __r_arr: [G; OUT_633] = { let __args: [G; IN_633] = [__v_8, __v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[633].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_633] = unsafe { *(result.output.as_ptr() as *const [G; OUT_633]) }; __ret } else { aiur_fn_633(__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; 3] = [__v_14, __v_8, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *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_12.as_canonical_u64() {
+          1u64 => {
+            let __v_16: G = G::from_u64(0);
+            let __v_17: G = { let __values: [G; 3] = [__v_16, __v_5, __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 __v_18: G = G::from_u64(0);
+            let __v_19: G = { let __values: [G; 3] = [__v_18, __v_13, __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_20: G = G::from_u64(1);
+            let __v_21: G = (__v_5 + __v_20);
+            let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = [__v_9, __v_1, __v_15, __v_17, __v_19, __v_21, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[637].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_637] = unsafe { *(result.output.as_ptr() as *const [G; OUT_637]) }; __ret } else { aiur_fn_637(__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 __ret: [G; OUT_637] = [__v_22, __v_23, __v_24, __v_25];
+            record.function_queries[637].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
-            let __v_11: G = G::from_u64(0);
-            let __ret: [G; OUT_707] = [__v_11];
-            record.function_queries[707].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __v_16: G = G::from_u64(1);
+            let __v_17: G = (__v_5 + __v_16);
+            let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = [__v_9, __v_1, __v_15, __v_3, __v_4, __v_17, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[637].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_637] = unsafe { *(result.output.as_ptr() as *const [G; OUT_637]) }; __ret } else { aiur_fn_637(__args, record, io_buffer, __cu)? } };
+            let __v_18: G = __r_arr[0];
+            let __v_19: G = __r_arr[1];
+            let __v_20: G = __r_arr[2];
+            let __v_21: G = __r_arr[3];
+            let __ret: [G; OUT_637] = [__v_18, __v_19, __v_20, __v_21];
+            record.function_queries[637].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
       },
-      2u64 => {
-        let __v_11: G = G::from_u64(0);
-        let __ret: [G; OUT_707] = [__v_11];
-        record.function_queries[707].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      3u64 => {
-        let __ret: [G; OUT_707] = [__v_4];
-        record.function_queries[707].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      4u64 => {
-        let __v_11: G = G::from_u64(0);
-        let __ret: [G; OUT_707] = [__v_11];
-        record.function_queries[707].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      5u64 => {
-        let __ret: [G; OUT_707] = [__v_6];
-        record.function_queries[707].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      6u64 => {
-        let __ret: [G; OUT_707] = [__v_7];
-        record.function_queries[707].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      7u64 => {
-        let __ret: [G; OUT_707] = [__v_9];
-        record.function_queries[707].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_708: usize = 2;
-const IN_708: usize = 2;
-const OUT_708: usize = 1;
-fn aiur_fn_708(
-  inp: [G; IN_708],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_708], 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() {
-      0u64 => {
-        let __v_6: G = G::from_u64(1);
-        let __ret: [G; OUT_708] = [__v_6];
-        record.function_queries[708].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      1u64 => {
-        let __v_6: G = G::from_u64(1);
-        let __ret: [G; OUT_708] = [__v_6];
-        record.function_queries[708].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      2u64 => {
-        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-        let __v_6: G = __r_arr[0];
-        let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].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];
-        let __v_17: G = __loaded[10];
-        let __v_18: G = G::from_u64(1);
-        let __r_arr: [G; OUT_707] = { let __args: [G; IN_707] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[707].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_707] = unsafe { *(result.output.as_ptr() as *const [G; OUT_707]) }; __ret } else { aiur_fn_707(__args, record, io_buffer, __cu)? } };
-        let __v_19: G = __r_arr[0];
-        let __v_20: G = (__v_18 - __v_19);
-        let __ret: [G; OUT_708] = [__v_20];
-        record.function_queries[708].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      3u64 => {
-        let __r_arr: [G; OUT_708] = { let __args: [G; IN_708] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[708].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_708] = unsafe { *(result.output.as_ptr() as *const [G; OUT_708]) }; __ret } else { aiur_fn_708(__args, record, io_buffer, __cu)? } };
-        let __v_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_708] = { let __args: [G; IN_708] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[708].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_708] = unsafe { *(result.output.as_ptr() as *const [G; OUT_708]) }; __ret } else { aiur_fn_708(__args, record, io_buffer, __cu)? } };
-        let __v_7: G = __r_arr[0];
-        let __v_8: G = (__v_6 * __v_7);
-        let __ret: [G; OUT_708] = [__v_8];
-        record.function_queries[708].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      4u64 => {
-        let __r_arr: [G; OUT_708] = { let __args: [G; IN_708] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[708].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_708] = unsafe { *(result.output.as_ptr() as *const [G; OUT_708]) }; __ret } else { aiur_fn_708(__args, record, io_buffer, __cu)? } };
-        let __v_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_708] = { let __args: [G; IN_708] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[708].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_708] = unsafe { *(result.output.as_ptr() as *const [G; OUT_708]) }; __ret } else { aiur_fn_708(__args, record, io_buffer, __cu)? } };
-        let __v_7: G = __r_arr[0];
-        let __v_8: G = (__v_6 * __v_7);
-        let __ret: [G; OUT_708] = [__v_8];
-        record.function_queries[708].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      5u64 => {
-        let __r_arr: [G; OUT_708] = { let __args: [G; IN_708] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[708].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_708] = unsafe { *(result.output.as_ptr() as *const [G; OUT_708]) }; __ret } else { aiur_fn_708(__args, record, io_buffer, __cu)? } };
-        let __v_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_708] = { let __args: [G; IN_708] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[708].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_708] = unsafe { *(result.output.as_ptr() as *const [G; OUT_708]) }; __ret } else { aiur_fn_708(__args, record, io_buffer, __cu)? } };
-        let __v_7: G = __r_arr[0];
-        let __v_8: G = (__v_6 * __v_7);
-        let __ret: [G; OUT_708] = [__v_8];
-        record.function_queries[708].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      6u64 => {
-        let __r_arr: [G; OUT_708] = { let __args: [G; IN_708] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[708].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_708] = unsafe { *(result.output.as_ptr() as *const [G; OUT_708]) }; __ret } else { aiur_fn_708(__args, record, io_buffer, __cu)? } };
-        let __v_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_708] = { let __args: [G; IN_708] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[708].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_708] = unsafe { *(result.output.as_ptr() as *const [G; OUT_708]) }; __ret } else { aiur_fn_708(__args, record, io_buffer, __cu)? } };
-        let __v_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_708] = { let __args: [G; IN_708] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[708].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_708] = unsafe { *(result.output.as_ptr() as *const [G; OUT_708]) }; __ret } else { aiur_fn_708(__args, record, io_buffer, __cu)? } };
-        let __v_8: G = __r_arr[0];
-        let __v_9: G = (__v_7 * __v_8);
-        let __v_10: G = (__v_6 * __v_9);
-        let __ret: [G; OUT_708] = [__v_10];
-        record.function_queries[708].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      7u64 => {
-        let __v_6: G = G::from_u64(1);
-        let __ret: [G; OUT_708] = [__v_6];
-        record.function_queries[708].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      8u64 => {
-        let __r_arr: [G; OUT_708] = { let __args: [G; IN_708] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[708].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_708] = unsafe { *(result.output.as_ptr() as *const [G; OUT_708]) }; __ret } else { aiur_fn_708(__args, record, io_buffer, __cu)? } };
-        let __v_6: G = __r_arr[0];
-        let __ret: [G; OUT_708] = [__v_6];
-        record.function_queries[708].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[709].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_709] = unsafe { *(result.output.as_ptr() as *const [G; OUT_709]) }; __ret } else { aiur_fn_709(__args, record, io_buffer, __cu)? } };
+        let __v_11: G = __r_arr[0];
+        let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[709].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_709] = unsafe { *(result.output.as_ptr() as *const [G; OUT_709]) }; __ret } else { aiur_fn_709(__args, record, io_buffer, __cu)? } };
+        let __v_12: G = __r_arr[0];
+        let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[709].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_709] = unsafe { *(result.output.as_ptr() as *const [G; OUT_709]) }; __ret } else { aiur_fn_709(__args, record, io_buffer, __cu)? } };
+        let __v_13: G = __r_arr[0];
+        let __ret: [G; OUT_637] = [__v_11, __v_12, __v_13, __v_0];
+        record.function_queries[637].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
     }
   })
 }
 
-const INPUT_SIZE_709: usize = 3;
-const IN_709: usize = 3;
-const OUT_709: usize = 0;
-fn aiur_fn_709(
-  inp: [G; IN_709],
+const INPUT_SIZE_638: usize = 4;
+const IN_638: usize = 4;
+const OUT_638: usize = 1;
+fn aiur_fn_638(
+  inp: [G; IN_638],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_709], ExecError> {
+) -> Result<[G; OUT_638], 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() {
+    let __v_3: G = inp[3];
+    let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; 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: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
+    let __v_4: G = __loaded[0];
+    let __v_5: G = __loaded[1];
+    let __v_6: G = __loaded[2];
+    let __v_7: G = __loaded[3];
+    let __v_8: G = __loaded[4];
+    let __v_9: G = __loaded[5];
+    match __v_4.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_709] = [];
-        record.function_queries[709].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        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_638] = [__v_12];
+        record.function_queries[638].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_708] = { let __args: [G; IN_708] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[708].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_708] = unsafe { *(result.output.as_ptr() as *const [G; OUT_708]) }; __ret } else { aiur_fn_708(__args, record, io_buffer, __cu)? } };
-        let __v_3: G = __r_arr[0];
-        let __v_4: G = G::from_u64(1);
-        if (__v_3 != __v_4) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_4.as_canonical_u64() });
+        let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[258].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_258] = unsafe { *(result.output.as_ptr() as *const [G; OUT_258]) }; __ret } else { aiur_fn_258(__args, record, io_buffer, __cu)? } };
+        let __v_10: G = __r_arr[0];
+        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; 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: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].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];
+        let __v_21: G = __loaded[10];
+        let __v_22: G = __loaded[11];
+        match __v_11.as_canonical_u64() {
+          5u64 => {
+            let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_5, __v_13, __v_14, __v_15, __v_8, __v_1, __v_2, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[602].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_602] = unsafe { *(result.output.as_ptr() as *const [G; OUT_602]) }; __ret } else { aiur_fn_602(__args, record, io_buffer, __cu)? } };
+            let __v_23: G = __r_arr[0];
+            let __v_24: G = G::from_u64(0);
+            let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_23, __v_3, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[325].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_325] = unsafe { *(result.output.as_ptr() as *const [G; OUT_325]) }; __ret } else { aiur_fn_325(__args, record, io_buffer, __cu)? } };
+            let __v_25: G = __r_arr[0];
+            let __v_26: G = G::from_u64(0);
+            let __v_27: G = G::from_u64(1);
+            let __v_28: G = (__v_3 + __v_27);
+            let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_9, __v_1, __v_2, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[638].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_638] = unsafe { *(result.output.as_ptr() as *const [G; OUT_638]) }; __ret } else { aiur_fn_638(__args, record, io_buffer, __cu)? } };
+            let __v_29: G = __r_arr[0];
+            let __v_30: G = { let __values: [G; 3] = [__v_26, __v_25, __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 __ret: [G; OUT_638] = [__v_30];
+            record.function_queries[638].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_9, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[638].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_638] = unsafe { *(result.output.as_ptr() as *const [G; OUT_638]) }; __ret } else { aiur_fn_638(__args, record, io_buffer, __cu)? } };
+            let __v_23: G = __r_arr[0];
+            let __ret: [G; OUT_638] = [__v_23];
+            record.function_queries[638].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
         }
-        let __ret: [G; OUT_709] = [];
-        record.function_queries[709].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64()));
+        return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_710: usize = 2;
-const IN_710: usize = 2;
-const OUT_710: usize = 0;
-fn aiur_fn_710(
-  inp: [G; IN_710],
+const INPUT_SIZE_639: usize = 13;
+const IN_639: usize = 13;
+const OUT_639: usize = 0;
+fn aiur_fn_639(
+  inp: [G; IN_639],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_710], ExecError> {
+) -> Result<[G; OUT_639], 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() {
-      0u64 => {
-        let __ret: [G; OUT_710] = [];
-        record.function_queries[710].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      1u64 => {
-        let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[710].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_710] = unsafe { *(result.output.as_ptr() as *const [G; OUT_710]) }; __ret } else { aiur_fn_710(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_710] = [];
-        record.function_queries[710].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      2u64 => {
-        let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[710].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_710] = unsafe { *(result.output.as_ptr() as *const [G; OUT_710]) }; __ret } else { aiur_fn_710(__args, record, io_buffer, __cu)? } };
-        let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[710].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_710] = unsafe { *(result.output.as_ptr() as *const [G; OUT_710]) }; __ret } else { aiur_fn_710(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_710] = [];
-        record.function_queries[710].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      3u64 => {
-        let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[710].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_710] = unsafe { *(result.output.as_ptr() as *const [G; OUT_710]) }; __ret } else { aiur_fn_710(__args, record, io_buffer, __cu)? } };
-        let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[710].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_710] = unsafe { *(result.output.as_ptr() as *const [G; OUT_710]) }; __ret } else { aiur_fn_710(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_710] = [];
-        record.function_queries[710].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      4u64 => {
-        let __v_5: G = { let __a_val = __v_3.as_canonical_u64(); let __b_val = __v_1.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_6: G = G::from_u64(1);
-        if (__v_5 != __v_6) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_6.as_canonical_u64() });
-        }
-        let __ret: [G; OUT_710] = [];
-        record.function_queries[710].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.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];
+    match __v_0.as_canonical_u64() {
+      7u64 => {
+        let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_2, __v_3, __v_5, __v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[570].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_570] = unsafe { *(result.output.as_ptr() as *const [G; OUT_570]) }; __ret } else { aiur_fn_570(__args, record, io_buffer, __cu)? } };
+        let __v_13: G = __r_arr[0];
+        let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[258].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_258] = unsafe { *(result.output.as_ptr() as *const [G; OUT_258]) }; __ret } else { aiur_fn_258(__args, record, io_buffer, __cu)? } };
+        let __v_14: G = __r_arr[0];
+        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+        let __v_15: G = __loaded[0];
+        let __v_16: G = __loaded[1];
+        let __v_17: G = __loaded[2];
+        let __v_18: G = __loaded[3];
+        let __v_19: G = __loaded[4];
+        let __v_20: G = __loaded[5];
+        let __v_21: G = __loaded[6];
+        let __v_22: G = __loaded[7];
+        let __v_23: G = __loaded[8];
+        let __v_24: G = __loaded[9];
+        let __v_25: G = __loaded[10];
+        let __v_26: G = __loaded[11];
+        match __v_15.as_canonical_u64() {
+          5u64 => {
+            let __r_arr: [G; OUT_568] = { let __args: [G; IN_568] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[568].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_568] = unsafe { *(result.output.as_ptr() as *const [G; OUT_568]) }; __ret } else { aiur_fn_568(__args, record, io_buffer, __cu)? } };
+            let __v_27: G = __r_arr[0];
+            let __r_arr: [G; OUT_568] = { let __args: [G; IN_568] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[568].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_568] = unsafe { *(result.output.as_ptr() as *const [G; OUT_568]) }; __ret } else { aiur_fn_568(__args, record, io_buffer, __cu)? } };
+            let __v_28: G = __r_arr[0];
+            let __v_29: G = G::from_u64(1);
+            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_10, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { 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_30: G = __r_arr[0];
+            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_3 + __v_5);
+            let __v_35: G = (__v_6 + __v_4);
+            let __v_36: G = (__v_34 + __v_35);
+            let __v_37: G = G::from_u64(1);
+            let __v_38: G = (__v_36 + __v_37);
+            let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_2, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } else { aiur_fn_535(__args, record, io_buffer, __cu)? } };
+            let __v_39: G = __r_arr[0];
+            let __v_40: G = (__v_5 + __v_6);
+            let __v_41: G = (__v_3 + __v_40);
+            let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_7, __v_41, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[642].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_642] = unsafe { *(result.output.as_ptr() as *const [G; OUT_642]) }; __ret } else { aiur_fn_642(__args, record, io_buffer, __cu)? } };
+            let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_33.as_canonical_u64() {
+  1u64 => {
+    break '__mc_0 [];
+  },
+  _ => {
+    if (__v_3 != __v_18) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_18.as_canonical_u64(), msg: Some("recursor parameter count differs from its inductive's".to_string()) });
     }
-  })
+    if (__v_4 != __v_19) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_4.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: Some("recursor index count differs from its inductive's".to_string()) });
+    }
+    let __v_42: G = (__v_18 + __v_19);
+    let __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = [__v_2, __v_3, __v_5, __v_6, __v_4, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[640].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_640] = unsafe { *(result.output.as_ptr() as *const [G; OUT_640]) }; __ret } else { aiur_fn_640(__args, record, io_buffer, __cu)? } };
+    break '__mc_0 [];
+  },
 }
-
-const INPUT_SIZE_711: usize = 2;
-const IN_711: usize = 2;
-const OUT_711: usize = 0;
-fn aiur_fn_711(
-  inp: [G; IN_711],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_711], 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_711] = [];
-        record.function_queries[711].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[710].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_710] = unsafe { *(result.output.as_ptr() as *const [G; OUT_710]) }; __ret } else { aiur_fn_710(__args, record, io_buffer, __cu)? } };
-        let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } else { aiur_fn_711(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_711] = [];
-        record.function_queries[711].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
+ };
+            let __r_arr: [G; OUT_566] = { let __args: [G; IN_566] = [__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_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[566].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_566] = unsafe { *(result.output.as_ptr() as *const [G; OUT_566]) }; __ret } else { aiur_fn_566(__args, record, io_buffer, __cu)? } };
+            let __v_42: G = __r_arr[0];
+            let __r_arr: [G; OUT_558] = { let __args: [G; IN_558] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[558].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_558] = unsafe { *(result.output.as_ptr() as *const [G; OUT_558]) }; __ret } else { aiur_fn_558(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[723].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_723] = unsafe { *(result.output.as_ptr() as *const [G; OUT_723]) }; __ret } else { aiur_fn_723(__args, record, io_buffer, __cu)? } };
+            let __v_43: G = __r_arr[0];
+            if (__v_43 != __v_20) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_43.as_canonical_u64(), rhs: __v_20.as_canonical_u64(), msg: Some("recursor rule count differs from the inductive's ctor count".to_string()) });
+            }
+            if (__v_8 != __v_42) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_8.as_canonical_u64(), rhs: __v_42.as_canonical_u64(), msg: Some("recursor k_flag disagrees with its inductive's K eligibility".to_string()) });
+            }
+            let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__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_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = unsafe { *(result.output.as_ptr() as *const [G; OUT_608]) }; __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } };
+            let __ret: [G; OUT_639] = [];
+            record.function_queries[639].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_15.as_canonical_u64()));
+          },
+        }
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+        return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_712: usize = 4;
-const IN_712: usize = 4;
-const OUT_712: usize = 0;
-fn aiur_fn_712(
-  inp: [G; IN_712],
+const INPUT_SIZE_640: usize = 6;
+const IN_640: usize = 6;
+const OUT_640: usize = 0;
+fn aiur_fn_640(
+  inp: [G; IN_640],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_712], ExecError> {
+) -> Result<[G; OUT_640], 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; 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_4: G = __loaded[0];
-    let __v_5: G = __loaded[1];
-    let __v_6: G = __loaded[2];
-    let __v_7: G = __loaded[3];
-    match __v_4.as_canonical_u64() {
-      0u64 => {
-        let __v_8: G = { let __a_val = __v_5.as_canonical_u64(); let __b_val = __v_1.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_9: G = G::from_u64(1);
-        if (__v_8 != __v_9) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_8.as_canonical_u64(), rhs: __v_9.as_canonical_u64() });
-        }
-        let __ret: [G; OUT_712] = [];
-        record.function_queries[712].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      1u64 => {
-        let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[710].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_710] = unsafe { *(result.output.as_ptr() as *const [G; OUT_710]) }; __ret } else { aiur_fn_710(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_712] = [];
-        record.function_queries[712].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      2u64 => {
-        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-        let __v_8: G = __r_arr[0];
-        let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].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 __v_17: G = __loaded[8];
-        let __v_18: G = __loaded[9];
-        let __v_19: G = __loaded[10];
-        let __r_arr: [G; OUT_471] = { let __args: [G; IN_471] = [__v_9, __v_10, __v_11, __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[471].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_471] = unsafe { *(result.output.as_ptr() as *const [G; OUT_471]) }; __ret } else { aiur_fn_471(__args, record, io_buffer, __cu)? } };
-        let __v_20: G = __r_arr[0];
-        let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { 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_21: G = __r_arr[0];
-        if (__v_21 != __v_20) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_21.as_canonical_u64(), rhs: __v_20.as_canonical_u64() });
-        }
-        let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_6, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } else { aiur_fn_711(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_712] = [];
-        record.function_queries[712].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      3u64 => {
-        let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[712].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_712] = unsafe { *(result.output.as_ptr() as *const [G; OUT_712]) }; __ret } else { aiur_fn_712(__args, record, io_buffer, __cu)? } };
-        let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[712].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_712] = unsafe { *(result.output.as_ptr() as *const [G; OUT_712]) }; __ret } else { aiur_fn_712(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_712] = [];
-        record.function_queries[712].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      4u64 => {
-        let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[712].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_712] = unsafe { *(result.output.as_ptr() as *const [G; OUT_712]) }; __ret } else { aiur_fn_712(__args, record, io_buffer, __cu)? } };
-        let __v_8: G = G::from_u64(1);
-        let __v_9: G = (__v_1 + __v_8);
-        let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_6, __v_9, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[712].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_712] = unsafe { *(result.output.as_ptr() as *const [G; OUT_712]) }; __ret } else { aiur_fn_712(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_712] = [];
-        record.function_queries[712].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = (__v_3 + __v_4);
+    let __v_7: G = (__v_2 + __v_6);
+    let __v_8: G = (__v_1 + __v_7);
+    let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } else { aiur_fn_535(__args, record, io_buffer, __cu)? } };
+    let __v_9: 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_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: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].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];
+    match __v_10.as_canonical_u64() {
       5u64 => {
-        let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[712].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_712] = unsafe { *(result.output.as_ptr() as *const [G; OUT_712]) }; __ret } else { aiur_fn_712(__args, record, io_buffer, __cu)? } };
-        let __v_8: G = G::from_u64(1);
-        let __v_9: G = (__v_1 + __v_8);
-        let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_6, __v_9, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[712].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_712] = unsafe { *(result.output.as_ptr() as *const [G; OUT_712]) }; __ret } else { aiur_fn_712(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_712] = [];
-        record.function_queries[712].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      6u64 => {
-        let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[712].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_712] = unsafe { *(result.output.as_ptr() as *const [G; OUT_712]) }; __ret } else { aiur_fn_712(__args, record, io_buffer, __cu)? } };
-        let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[712].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_712] = unsafe { *(result.output.as_ptr() as *const [G; OUT_712]) }; __ret } else { aiur_fn_712(__args, record, io_buffer, __cu)? } };
-        let __v_8: G = G::from_u64(1);
-        let __v_9: G = (__v_1 + __v_8);
-        let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_7, __v_9, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[712].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_712] = unsafe { *(result.output.as_ptr() as *const [G; OUT_712]) }; __ret } else { aiur_fn_712(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_712] = [];
-        record.function_queries[712].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      7u64 => {
-        let __ret: [G; OUT_712] = [];
-        record.function_queries[712].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      8u64 => {
-        let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_7, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[712].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_712] = unsafe { *(result.output.as_ptr() as *const [G; OUT_712]) }; __ret } else { aiur_fn_712(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_712] = [];
-        record.function_queries[712].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[106].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_106] = unsafe { *(result.output.as_ptr() as *const [G; OUT_106]) }; __ret } else { aiur_fn_106(__args, record, io_buffer, __cu)? } };
+        let __v_14: G = __r_arr[0];
+        let __v_15: G = __r_arr[1];
+        let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } else { aiur_fn_711(__args, record, io_buffer, __cu)? } };
+        let __v_16: G = __r_arr[0];
+        if (__v_16 != __v_5) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_5.as_canonical_u64(), msg: Some("recursor major premise has the wrong number of spine args".to_string()) });
+        }
+        let __ret: [G; OUT_640] = [];
+        record.function_queries[640].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
+        return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_713: usize = 12;
-const IN_713: usize = 12;
-const OUT_713: usize = 0;
-fn aiur_fn_713(
-  inp: [G; IN_713],
+const INPUT_SIZE_641: usize = 2;
+const IN_641: usize = 2;
+const OUT_641: usize = 1;
+fn aiur_fn_641(
+  inp: [G; IN_641],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_713], ExecError> {
+) -> Result<[G; OUT_641], 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 __r_arr: [G; OUT_471] = { let __args: [G; IN_471] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[471].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_471] = unsafe { *(result.output.as_ptr() as *const [G; OUT_471]) }; __ret } else { aiur_fn_471(__args, record, io_buffer, __cu)? } };
-    let __v_12: G = __r_arr[0];
-    let __r_arr: [G; OUT_470] = { let __args: [G; IN_470] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[470].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_470] = unsafe { *(result.output.as_ptr() as *const [G; OUT_470]) }; __ret } else { aiur_fn_470(__args, record, io_buffer, __cu)? } };
-    let __v_13: G = __r_arr[0];
-    let __v_14: G = G::from_u64(0);
-    let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_13, __v_14, __v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[712].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_712] = unsafe { *(result.output.as_ptr() as *const [G; OUT_712]) }; __ret } else { aiur_fn_712(__args, record, io_buffer, __cu)? } };
-    match __v_0.as_canonical_u64() {
-      1u64 => {
-        let __v_15: G = G::from_u64(0);
-        let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_3, __v_15, __v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[712].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_712] = unsafe { *(result.output.as_ptr() as *const [G; OUT_712]) }; __ret } else { aiur_fn_712(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_713] = [];
-        record.function_queries[713].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      2u64 => {
-        let __v_15: G = G::from_u64(0);
-        let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_3, __v_15, __v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[712].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_712] = unsafe { *(result.output.as_ptr() as *const [G; OUT_712]) }; __ret } else { aiur_fn_712(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_713] = [];
-        record.function_queries[713].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      3u64 => {
-        let __v_15: G = G::from_u64(0);
-        let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_3, __v_15, __v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[712].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_712] = unsafe { *(result.output.as_ptr() as *const [G; OUT_712]) }; __ret } else { aiur_fn_712(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_713] = [];
-        record.function_queries[713].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      7u64 => {
-        let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_7, __v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = unsafe { *(result.output.as_ptr() as *const [G; OUT_714]) }; __ret } else { aiur_fn_714(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_713] = [];
-        record.function_queries[713].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __v_2: G = (__v_0 - __v_1);
+    match __v_2.as_canonical_u64() {
+      0u64 => {
+        let __v_3: G = G::from_u64(1);
+        let __v_4: G = G::from_u64(1);
+        let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __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 __ret: [G; OUT_641] = [__v_5];
+        record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __ret: [G; OUT_713] = [];
-        record.function_queries[713].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __v_3: G = G::from_u64(0);
+        let __v_4: G = G::from_u64(4);
+        let __v_5: G = G::from_u64(0);
+        let __v_6: G = { let __values: [G; 3] = [__v_4, __v_1, __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 __v_7: G = G::from_u64(1);
+        let __v_8: G = (__v_1 + __v_7);
+        let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[641].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_641] = unsafe { *(result.output.as_ptr() as *const [G; OUT_641]) }; __ret } else { aiur_fn_641(__args, record, io_buffer, __cu)? } };
+        let __v_9: G = __r_arr[0];
+        let __v_10: G = { let __values: [G; 3] = [__v_3, __v_6, __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 __ret: [G; OUT_641] = [__v_10];
+        record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_714: usize = 3;
-const IN_714: usize = 3;
-const OUT_714: usize = 0;
-fn aiur_fn_714(
-  inp: [G; IN_714],
+const INPUT_SIZE_642: usize = 3;
+const IN_642: usize = 3;
+const OUT_642: usize = 0;
+fn aiur_fn_642(
+  inp: [G; IN_642],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_714], ExecError> {
+) -> Result<[G; OUT_642], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -59637,18 +52520,18 @@ fn aiur_fn_714(
     let __v_7: G = __loaded[4];
     match __v_3.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_714] = [];
-        record.function_queries[714].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_642] = [];
+        record.function_queries[642].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         match __v_4.as_canonical_u64() {
           _ => {
-            let __v_8: G = G::from_u64(0);
-            let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_6, __v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[712].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_712] = unsafe { *(result.output.as_ptr() as *const [G; OUT_712]) }; __ret } else { aiur_fn_712(__args, record, io_buffer, __cu)? } };
-            let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_7, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = unsafe { *(result.output.as_ptr() as *const [G; OUT_714]) }; __ret } else { aiur_fn_714(__args, record, io_buffer, __cu)? } };
-            let __ret: [G; OUT_714] = [];
-            record.function_queries[714].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __v_8: G = (__v_1 + __v_5);
+            let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_6, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } else { aiur_fn_527(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_7, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[642].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_642] = unsafe { *(result.output.as_ptr() as *const [G; OUT_642]) }; __ret } else { aiur_fn_642(__args, record, io_buffer, __cu)? } };
+            let __ret: [G; OUT_642] = [];
+            record.function_queries[642].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -59660,86 +52543,68 @@ fn aiur_fn_714(
   })
 }
 
-const INPUT_SIZE_715: usize = 2;
-const IN_715: usize = 2;
-const OUT_715: usize = 0;
-fn aiur_fn_715(
-  inp: [G; IN_715],
+const INPUT_SIZE_643: usize = 4;
+const IN_643: usize = 4;
+const OUT_643: usize = 3;
+fn aiur_fn_643(
+  inp: [G; IN_643],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_715], ExecError> {
+) -> Result<[G; OUT_643], 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_244] = { let __args: [G; IN_244] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } else { aiur_fn_244(__args, record, io_buffer, __cu)? } };
-    let __v_2: G = __r_arr[0];
-    let __v_3: G = G::from_u64(0);
-    let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_2, __v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[480].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_480] = unsafe { *(result.output.as_ptr() as *const [G; OUT_480]) }; __ret } else { aiur_fn_480(__args, record, io_buffer, __cu)? } };
-    let __v_4: G = __r_arr[0];
-    let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-    let __v_5: G = __r_arr[0];
-    let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].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];
-    let __v_13: G = __loaded[7];
-    let __v_14: G = __loaded[8];
-    let __v_15: G = __loaded[9];
-    let __v_16: G = __loaded[10];
-    match __v_6.as_canonical_u64() {
-      5u64 => {
-        let __v_17: G = G::from_u64(0);
-        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_11, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-        let __v_18: G = __r_arr[0];
-        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_1, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-        let __v_19: G = __r_arr[0];
-        let __v_20: G = G::from_u64(1);
-        if (__v_7 != __v_20) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_20.as_canonical_u64() });
-        }
-        let __v_21: G = G::from_u64(2);
-        if (__v_9 != __v_21) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_21.as_canonical_u64() });
-        }
-        let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { 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_22: G = __r_arr[0];
-        let __v_23: G = G::from_u64(1);
-        if (__v_22 != __v_23) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_22.as_canonical_u64(), rhs: __v_23.as_canonical_u64() });
-        }
-        let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } else { aiur_fn_245(__args, record, io_buffer, __cu)? } };
-        let __v_24: G = __r_arr[0];
-        let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_19, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_25: G = __r_arr[0];
-        let __v_26: G = G::from_u64(1);
-        if (__v_25 != __v_26) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_25.as_canonical_u64(), rhs: __v_26.as_canonical_u64() });
-        }
-        let __ret: [G; OUT_715] = [];
-        record.function_queries[715].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    match __v_1.as_canonical_u64() {
+      0u64 => {
+        let __ret: [G; OUT_643] = [__v_0, __v_2, __v_3];
+        record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64()));
+        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_4: G = __loaded[0];
+        let __v_5: G = __loaded[1];
+        let __v_6: G = __loaded[2];
+        let __v_7: G = __loaded[3];
+        match __v_4.as_canonical_u64() {
+          4u64 => {
+            let __v_8: G = G::from_u64(1);
+            let __v_9: G = (__v_1 - __v_8);
+            let __v_10: G = G::from_u64(1);
+            let __v_11: G = (__v_2 + __v_10);
+            let __v_12: G = G::from_u64(0);
+            let __v_13: G = { let __values: [G; 3] = [__v_12, __v_5, __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_643] = { let __args: [G; IN_643] = [__v_6, __v_9, __v_11, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[643].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_643] = unsafe { *(result.output.as_ptr() as *const [G; OUT_643]) }; __ret } else { aiur_fn_643(__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 __ret: [G; OUT_643] = [__v_14, __v_15, __v_16];
+            record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            let __ret: [G; OUT_643] = [__v_0, __v_2, __v_3];
+            record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+        }
       },
     }
   })
 }
 
-const INPUT_SIZE_716: usize = 14;
-const IN_716: usize = 14;
-const OUT_716: usize = 0;
-fn aiur_fn_716(
-  inp: [G; IN_716],
+const INPUT_SIZE_644: usize = 13;
+const IN_644: usize = 13;
+const OUT_644: usize = 0;
+fn aiur_fn_644(
+  inp: [G; IN_644],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_716], ExecError> {
+) -> Result<[G; OUT_644], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -59754,129 +52619,133 @@ fn aiur_fn_716(
     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 __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_0, __v_1, __v_2, __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[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } };
-    let __r_arr: [G; OUT_707] = { let __args: [G; IN_707] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[707].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_707] = unsafe { *(result.output.as_ptr() as *const [G; OUT_707]) }; __ret } else { aiur_fn_707(__args, record, io_buffer, __cu)? } };
-    let __v_14: G = __r_arr[0];
+    let __r_arr: [G; OUT_522] = { let __args: [G; IN_522] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[522].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_522] = unsafe { *(result.output.as_ptr() as *const [G; OUT_522]) }; __ret } else { aiur_fn_522(__args, record, io_buffer, __cu)? } };
+    let __v_13: G = __r_arr[0];
     match __v_0.as_canonical_u64() {
       0u64 => {
+        let __v_14: G = G::from_u64(0);
+        let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } else { aiur_fn_527(__args, record, io_buffer, __cu)? } };
         let __v_15: G = G::from_u64(1);
         let __v_16: G = G::from_u64(1);
         let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_465] = { let __args: [G; IN_465] = [__v_2, __v_17, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[465].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_465] = unsafe { *(result.output.as_ptr() as *const [G; OUT_465]) }; __ret } else { aiur_fn_465(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[444].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_444] = unsafe { *(result.output.as_ptr() as *const [G; OUT_444]) }; __ret } else { aiur_fn_444(__args, record, io_buffer, __cu)? } };
         let __v_18: G = __r_arr[0];
-        let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_14, __v_2, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[709].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_709] = unsafe { *(result.output.as_ptr() as *const [G; OUT_709]) }; __ret } else { aiur_fn_709(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_716] = [];
-        record.function_queries[716].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } else { aiur_fn_524(__args, record, io_buffer, __cu)? } };
+        let __ret: [G; OUT_644] = [];
+        record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
-        let __v_15: G = G::from_u64(1);
+        let __v_14: G = G::from_u64(0);
+        let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } else { aiur_fn_527(__args, record, io_buffer, __cu)? } };
+        let __v_15: G = G::from_u64(0);
+        let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_3, __v_15, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } else { aiur_fn_527(__args, record, io_buffer, __cu)? } };
         let __v_16: G = G::from_u64(1);
-        let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_465] = { let __args: [G; IN_465] = [__v_2, __v_17, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[465].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_465] = unsafe { *(result.output.as_ptr() as *const [G; OUT_465]) }; __ret } else { aiur_fn_465(__args, record, io_buffer, __cu)? } };
-        let __v_18: G = __r_arr[0];
-        let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_14, __v_2, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[709].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_709] = unsafe { *(result.output.as_ptr() as *const [G; OUT_709]) }; __ret } else { aiur_fn_709(__args, record, io_buffer, __cu)? } };
-        let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_14, __v_3, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[709].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_709] = unsafe { *(result.output.as_ptr() as *const [G; OUT_709]) }; __ret } else { aiur_fn_709(__args, record, io_buffer, __cu)? } };
-        let __v_19: G = G::from_u64(1);
+        let __v_17: G = G::from_u64(1);
+        let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __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 __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_2, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[444].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_444] = unsafe { *(result.output.as_ptr() as *const [G; OUT_444]) }; __ret } else { aiur_fn_444(__args, record, io_buffer, __cu)? } };
+        let __v_19: G = __r_arr[0];
+        let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } else { aiur_fn_524(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_13, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } else { aiur_fn_524(__args, record, io_buffer, __cu)? } };
         let __v_20: G = G::from_u64(1);
-        let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __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 __r_arr: [G; OUT_466] = { let __args: [G; IN_466] = [__v_3, __v_2, __v_21, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[466].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_466] = unsafe { *(result.output.as_ptr() as *const [G; OUT_466]) }; __ret } else { aiur_fn_466(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_716] = [];
-        record.function_queries[716].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __v_21: G = G::from_u64(1);
+        let __v_22: G = { let __values: [G; 3] = [__v_20, __v_21, __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 __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_3, __v_2, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[445].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_445] = unsafe { *(result.output.as_ptr() as *const [G; OUT_445]) }; __ret } else { aiur_fn_445(__args, record, io_buffer, __cu)? } };
+        let __ret: [G; OUT_644] = [];
+        record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
-        let __v_15: G = G::from_u64(1);
+        let __v_14: G = G::from_u64(0);
+        let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } else { aiur_fn_527(__args, record, io_buffer, __cu)? } };
+        let __v_15: G = G::from_u64(0);
+        let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_3, __v_15, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } else { aiur_fn_527(__args, record, io_buffer, __cu)? } };
         let __v_16: G = G::from_u64(1);
-        let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_465] = { let __args: [G; IN_465] = [__v_2, __v_17, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[465].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_465] = unsafe { *(result.output.as_ptr() as *const [G; OUT_465]) }; __ret } else { aiur_fn_465(__args, record, io_buffer, __cu)? } };
-        let __v_18: G = __r_arr[0];
-        let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_14, __v_2, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[709].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_709] = unsafe { *(result.output.as_ptr() as *const [G; OUT_709]) }; __ret } else { aiur_fn_709(__args, record, io_buffer, __cu)? } };
-        let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_14, __v_3, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[709].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_709] = unsafe { *(result.output.as_ptr() as *const [G; OUT_709]) }; __ret } else { aiur_fn_709(__args, record, io_buffer, __cu)? } };
-        let __v_19: G = G::from_u64(1);
-        let __v_20: G = G::from_u64(1);
-        let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __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 __r_arr: [G; OUT_466] = { let __args: [G; IN_466] = [__v_3, __v_2, __v_21, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[466].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_466] = unsafe { *(result.output.as_ptr() as *const [G; OUT_466]) }; __ret } else { aiur_fn_466(__args, record, io_buffer, __cu)? } };
-        let __v_22: G = G::from_u64(0);
-        let __v_23: G = G::from_u64(0);
-        let __v_24: G = { let __values: [G; 3] = [__v_22, __v_23, __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 __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_18, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[216].get_mut(&__args[..]) { 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_25: G = __r_arr[0];
-        let __v_26: G = G::from_u64(1);
-        if (__v_25 != __v_26) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_25.as_canonical_u64(), rhs: __v_26.as_canonical_u64() });
+        let __v_17: G = G::from_u64(1);
+        let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __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 __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_2, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[444].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_444] = unsafe { *(result.output.as_ptr() as *const [G; OUT_444]) }; __ret } else { aiur_fn_444(__args, record, io_buffer, __cu)? } };
+        let __v_19: G = __r_arr[0];
+        let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } else { aiur_fn_524(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_13, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } else { aiur_fn_524(__args, record, io_buffer, __cu)? } };
+        let __v_20: G = G::from_u64(0);
+        let __v_21: G = G::from_u64(0);
+        let __v_22: G = { let __values: [G; 3] = [__v_20, __v_21, __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 __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_19, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } else { aiur_fn_295(__args, record, io_buffer, __cu)? } };
+        let __v_23: G = __r_arr[0];
+        let __v_24: G = G::from_u64(1);
+        if (__v_23 != __v_24) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_23.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: Some("theorem's type is not a Prop".to_string()) });
         }
-        let __ret: [G; OUT_716] = [];
-        record.function_queries[716].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __v_25: G = G::from_u64(1);
+        let __v_26: G = G::from_u64(1);
+        let __v_27: G = { let __values: [G; 3] = [__v_25, __v_26, __v_26]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_445] = { let __args: [G; IN_445] = [__v_3, __v_2, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[445].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_445] = unsafe { *(result.output.as_ptr() as *const [G; OUT_445]) }; __ret } else { aiur_fn_445(__args, record, io_buffer, __cu)? } };
+        let __ret: [G; OUT_644] = [];
+        record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       3u64 => {
-        let __v_15: G = G::from_u64(1);
+        let __v_14: G = G::from_u64(0);
+        let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } else { aiur_fn_527(__args, record, io_buffer, __cu)? } };
+        let __v_15: G = G::from_u64(0);
+        let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_3, __v_15, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } else { aiur_fn_527(__args, record, io_buffer, __cu)? } };
         let __v_16: G = G::from_u64(1);
-        let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_465] = { let __args: [G; IN_465] = [__v_2, __v_17, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[465].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_465] = unsafe { *(result.output.as_ptr() as *const [G; OUT_465]) }; __ret } else { aiur_fn_465(__args, record, io_buffer, __cu)? } };
-        let __v_18: G = __r_arr[0];
-        let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_14, __v_2, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[709].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_709] = unsafe { *(result.output.as_ptr() as *const [G; OUT_709]) }; __ret } else { aiur_fn_709(__args, record, io_buffer, __cu)? } };
-        let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_14, __v_3, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[709].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_709] = unsafe { *(result.output.as_ptr() as *const [G; OUT_709]) }; __ret } else { aiur_fn_709(__args, record, io_buffer, __cu)? } };
-        match __v_4.as_canonical_u64() {
-          1u64 => {
-            let __ret: [G; OUT_716] = [];
-            record.function_queries[716].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          0u64 => {
-            let __v_19: G = G::from_u64(1);
-            let __v_20: G = G::from_u64(1);
-            let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __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 __r_arr: [G; OUT_466] = { let __args: [G; IN_466] = [__v_3, __v_2, __v_21, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[466].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_466] = unsafe { *(result.output.as_ptr() as *const [G; OUT_466]) }; __ret } else { aiur_fn_466(__args, record, io_buffer, __cu)? } };
-            let __ret: [G; OUT_716] = [];
-            record.function_queries[716].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
-          },
-        }
+        let __v_17: G = G::from_u64(1);
+        let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __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 __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_2, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[444].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_444] = unsafe { *(result.output.as_ptr() as *const [G; OUT_444]) }; __ret } else { aiur_fn_444(__args, record, io_buffer, __cu)? } };
+        let __v_19: G = __r_arr[0];
+        let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } else { aiur_fn_524(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_13, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } else { aiur_fn_524(__args, record, io_buffer, __cu)? } };
+        let __v_20: G = G::from_u64(1);
+        let __v_21: G = G::from_u64(1);
+        let __v_22: G = { let __values: [G; 3] = [__v_20, __v_21, __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 __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_3, __v_2, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[445].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_445] = unsafe { *(result.output.as_ptr() as *const [G; OUT_445]) }; __ret } else { aiur_fn_445(__args, record, io_buffer, __cu)? } };
+        let __ret: [G; OUT_644] = [];
+        record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
       4u64 => {
+        let __v_14: G = G::from_u64(0);
+        let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } else { aiur_fn_527(__args, record, io_buffer, __cu)? } };
         let __v_15: G = G::from_u64(1);
         let __v_16: G = G::from_u64(1);
         let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_465] = { let __args: [G; IN_465] = [__v_2, __v_17, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[465].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_465] = unsafe { *(result.output.as_ptr() as *const [G; OUT_465]) }; __ret } else { aiur_fn_465(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[444].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_444] = unsafe { *(result.output.as_ptr() as *const [G; OUT_444]) }; __ret } else { aiur_fn_444(__args, record, io_buffer, __cu)? } };
         let __v_18: G = __r_arr[0];
-        let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_14, __v_2, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[709].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_709] = unsafe { *(result.output.as_ptr() as *const [G; OUT_709]) }; __ret } else { aiur_fn_709(__args, record, io_buffer, __cu)? } };
-        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_13, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-        let __v_19: G = __r_arr[0];
-        let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_19, __v_3, __v_1, __v_2, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_716] = [];
-        record.function_queries[716].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } else { aiur_fn_524(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_12, __v_3, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } else { aiur_fn_534(__args, record, io_buffer, __cu)? } };
+        let __ret: [G; OUT_644] = [];
+        record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       5u64 => {
+        let __v_14: G = G::from_u64(0);
+        let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } else { aiur_fn_527(__args, record, io_buffer, __cu)? } };
         let __v_15: G = G::from_u64(1);
         let __v_16: G = G::from_u64(1);
         let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_465] = { let __args: [G; IN_465] = [__v_2, __v_17, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[465].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_465] = unsafe { *(result.output.as_ptr() as *const [G; OUT_465]) }; __ret } else { aiur_fn_465(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[444].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_444] = unsafe { *(result.output.as_ptr() as *const [G; OUT_444]) }; __ret } else { aiur_fn_444(__args, record, io_buffer, __cu)? } };
         let __v_18: G = __r_arr[0];
-        let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_14, __v_2, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[709].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_709] = unsafe { *(result.output.as_ptr() as *const [G; OUT_709]) }; __ret } else { aiur_fn_709(__args, record, io_buffer, __cu)? } };
-        let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_11, __v_2, __v_3, __v_4, __v_7, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[650].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_650] = unsafe { *(result.output.as_ptr() as *const [G; OUT_650]) }; __ret } else { aiur_fn_650(__args, record, io_buffer, __cu)? } };
-        let __r_arr: [G; OUT_514] = { let __args: [G; IN_514] = [__v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[514].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_514] = unsafe { *(result.output.as_ptr() as *const [G; OUT_514]) }; __ret } else { aiur_fn_514(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_716] = [];
-        record.function_queries[716].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } else { aiur_fn_524(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_521] = { let __args: [G; IN_521] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[521].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_521] = unsafe { *(result.output.as_ptr() as *const [G; OUT_521]) }; __ret } else { aiur_fn_521(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_556] = { let __args: [G; IN_556] = [__v_2, __v_3, __v_4, __v_5, __v_1, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[556].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_556] = unsafe { *(result.output.as_ptr() as *const [G; OUT_556]) }; __ret } else { aiur_fn_556(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_559] = { let __args: [G; IN_559] = [__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]; let __cu = unconstrained; if let Some(result) = record.function_queries[559].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_559] = unsafe { *(result.output.as_ptr() as *const [G; OUT_559]) }; __ret } else { aiur_fn_559(__args, record, io_buffer, __cu)? } };
+        let __ret: [G; OUT_644] = [];
+        record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       6u64 => {
+        let __v_14: G = G::from_u64(0);
+        let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } else { aiur_fn_527(__args, record, io_buffer, __cu)? } };
         let __v_15: G = G::from_u64(1);
         let __v_16: G = G::from_u64(1);
         let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_465] = { let __args: [G; IN_465] = [__v_2, __v_17, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[465].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_465] = unsafe { *(result.output.as_ptr() as *const [G; OUT_465]) }; __ret } else { aiur_fn_465(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[444].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_444] = unsafe { *(result.output.as_ptr() as *const [G; OUT_444]) }; __ret } else { aiur_fn_444(__args, record, io_buffer, __cu)? } };
         let __v_18: G = __r_arr[0];
-        let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_14, __v_2, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[709].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_709] = unsafe { *(result.output.as_ptr() as *const [G; OUT_709]) }; __ret } else { aiur_fn_709(__args, record, io_buffer, __cu)? } };
-        let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = [__v_11, __v_0, __v_1, __v_2, __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[594].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_594] = unsafe { *(result.output.as_ptr() as *const [G; OUT_594]) }; __ret } else { aiur_fn_594(__args, record, io_buffer, __cu)? } };
-        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_12, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } else { aiur_fn_524(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } else { aiur_fn_546(__args, record, io_buffer, __cu)? } };
         let __v_19: G = __r_arr[0];
-        let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr };
+        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; 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: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
         let __v_20: G = __loaded[0];
         let __v_21: G = __loaded[1];
         let __v_22: G = __loaded[2];
@@ -59888,29 +52757,27 @@ fn aiur_fn_716(
         let __v_28: G = __loaded[8];
         let __v_29: G = __loaded[9];
         let __v_30: G = __loaded[10];
+        let __v_31: G = __loaded[11];
         match __v_20.as_canonical_u64() {
           5u64 => {
-            let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_22, __v_2, __v_23, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = unsafe { *(result.output.as_ptr() as *const [G; OUT_652]) }; __ret } else { aiur_fn_652(__args, record, io_buffer, __cu)? } };
-            let __r_arr: [G; OUT_513] = { let __args: [G; IN_513] = [__v_2, __v_5, __v_24, __v_6, __v_3, __v_21, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[513].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_513] = unsafe { *(result.output.as_ptr() as *const [G; OUT_513]) }; __ret } else { aiur_fn_513(__args, record, io_buffer, __cu)? } };
-            let __v_31: G = (__v_23 + __v_24);
-            let __v_32: G = G::from_u64(1);
+            let __r_arr: [G; OUT_541] = { let __args: [G; IN_541] = [__v_22, __v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[541].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_541] = unsafe { *(result.output.as_ptr() as *const [G; OUT_541]) }; __ret } else { aiur_fn_541(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_2, __v_6, __v_24, __v_7, __v_21, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[539].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_539] = unsafe { *(result.output.as_ptr() as *const [G; OUT_539]) }; __ret } else { aiur_fn_539(__args, record, io_buffer, __cu)? } };
+            let __v_32: G = (__v_23 + __v_24);
             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 __r_arr: [G; OUT_519] = { let __args: [G; IN_519] = [__v_22, __v_31, __v_34, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[519].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_519] = unsafe { *(result.output.as_ptr() as *const [G; OUT_519]) }; __ret } else { aiur_fn_519(__args, record, io_buffer, __cu)? } };
-            let __v_35: G = __r_arr[0];
-            let __v_36: G = G::from_u64(1);
-            let __v_37: G = G::from_u64(1);
-            let __v_38: G = { let __values: [G; 3] = [__v_36, __v_37, __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 __r_arr: [G; OUT_520] = { let __args: [G; IN_520] = [__v_2, __v_5, __v_35, __v_38, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[520].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_520] = unsafe { *(result.output.as_ptr() as *const [G; OUT_520]) }; __ret } else { aiur_fn_520(__args, record, io_buffer, __cu)? } };
-            let __v_39: G = G::from_u64(1);
-            let __v_40: G = G::from_u64(1);
-            let __v_41: G = { let __values: [G; 3] = [__v_39, __v_40, __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 __r_arr: [G; OUT_523] = { let __args: [G; IN_523] = [__v_2, __v_5, __v_3, __v_41, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[523].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_523] = unsafe { *(result.output.as_ptr() as *const [G; OUT_523]) }; __ret } else { aiur_fn_523(__args, record, io_buffer, __cu)? } };
-            if (__v_5 != __v_23) {
-              return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_23.as_canonical_u64() });
+            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 __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_22, __v_32, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } else { aiur_fn_542(__args, record, io_buffer, __cu)? } };
+            let __v_36: G = __r_arr[0];
+            let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_2, __v_6, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[545].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_545] = unsafe { *(result.output.as_ptr() as *const [G; OUT_545]) }; __ret } else { aiur_fn_545(__args, record, io_buffer, __cu)? } };
+            if (__v_6 != __v_23) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_23.as_canonical_u64(), msg: Some("ctor parameter count differs from its inductive's".to_string()) });
             }
-            let __ret: [G; OUT_716] = [];
-            record.function_queries[716].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            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 __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_2, __v_6, __v_3, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[555].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_555] = unsafe { *(result.output.as_ptr() as *const [G; OUT_555]) }; __ret } else { aiur_fn_555(__args, record, io_buffer, __cu)? } };
+            let __ret: [G; OUT_644] = [];
+            record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -59919,15 +52786,18 @@ fn aiur_fn_716(
         }
       },
       7u64 => {
+        let __v_14: G = G::from_u64(0);
+        let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } else { aiur_fn_527(__args, record, io_buffer, __cu)? } };
         let __v_15: G = G::from_u64(1);
         let __v_16: G = G::from_u64(1);
         let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_465] = { let __args: [G; IN_465] = [__v_2, __v_17, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[465].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_465] = unsafe { *(result.output.as_ptr() as *const [G; OUT_465]) }; __ret } else { aiur_fn_465(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[444].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_444] = unsafe { *(result.output.as_ptr() as *const [G; OUT_444]) }; __ret } else { aiur_fn_444(__args, record, io_buffer, __cu)? } };
         let __v_18: G = __r_arr[0];
-        let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_14, __v_2, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[709].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_709] = unsafe { *(result.output.as_ptr() as *const [G; OUT_709]) }; __ret } else { aiur_fn_709(__args, record, io_buffer, __cu)? } };
-        let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_11, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_716] = [];
-        record.function_queries[716].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } else { aiur_fn_524(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_521] = { let __args: [G; IN_521] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[521].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_521] = unsafe { *(result.output.as_ptr() as *const [G; OUT_521]) }; __ret } else { aiur_fn_521(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__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]; let __cu = unconstrained; if let Some(result) = record.function_queries[639].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_639] = unsafe { *(result.output.as_ptr() as *const [G; OUT_639]) }; __ret } else { aiur_fn_639(__args, record, io_buffer, __cu)? } };
+        let __ret: [G; OUT_644] = [];
+        record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -59937,492 +52807,476 @@ fn aiur_fn_716(
   })
 }
 
-const INPUT_SIZE_717: usize = 6;
-const IN_717: usize = 6;
-const OUT_717: usize = 0;
-fn aiur_fn_717(
-  inp: [G; IN_717],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_717], 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 __mc_out___mc_0: [G; 2] = '__mc_0: { match __v_1.as_canonical_u64() {
-  0u64 => {
-    let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } };
-    let __v_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_7: G = __r_arr[0];
-    let __v_8: G = G::from_u64(1);
-    if (__v_7 != __v_8) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_8.as_canonical_u64() });
-    }
-    let __v_9: G = G::from_u64(1);
-    let __v_10: G = G::from_u64(2);
-    break '__mc_0 [__v_9, __v_10];
-  },
-  1u64 => {
-    let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[234].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_234] = unsafe { *(result.output.as_ptr() as *const [G; OUT_234]) }; __ret } else { aiur_fn_234(__args, record, io_buffer, __cu)? } };
-    let __v_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_7: G = __r_arr[0];
-    let __v_8: G = G::from_u64(1);
-    if (__v_7 != __v_8) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_8.as_canonical_u64() });
-    }
-    let __v_9: G = G::from_u64(1);
-    let __v_10: G = G::from_u64(3);
-    break '__mc_0 [__v_9, __v_10];
-  },
-  2u64 => {
-    let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[715].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_715] = unsafe { *(result.output.as_ptr() as *const [G; OUT_715]) }; __ret } else { aiur_fn_715(__args, record, io_buffer, __cu)? } };
-    let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[235].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_235] = unsafe { *(result.output.as_ptr() as *const [G; OUT_235]) }; __ret } else { aiur_fn_235(__args, record, io_buffer, __cu)? } };
-    let __v_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_7: G = __r_arr[0];
-    let __v_8: G = G::from_u64(1);
-    if (__v_7 != __v_8) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_8.as_canonical_u64() });
-    }
-    let __v_9: G = G::from_u64(2);
-    let __v_10: G = G::from_u64(6);
-    break '__mc_0 [__v_9, __v_10];
-  },
-  3u64 => {
-    let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[236].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_236] = unsafe { *(result.output.as_ptr() as *const [G; OUT_236]) }; __ret } else { aiur_fn_236(__args, record, io_buffer, __cu)? } };
-    let __v_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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_7: G = __r_arr[0];
-    let __v_8: G = G::from_u64(1);
-    if (__v_7 != __v_8) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_8.as_canonical_u64() });
-    }
-    let __v_9: G = G::from_u64(1);
-    let __v_10: G = G::from_u64(5);
-    break '__mc_0 [__v_9, __v_10];
-  },
-  _ => {
-    return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
-  },
-}
- };
-    let __v_6: G = __mc_out___mc_0[0];
-    let __v_7: G = __mc_out___mc_0[1];
-    if (__v_2 != __v_6) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_2.as_canonical_u64(), rhs: __v_6.as_canonical_u64() });
-    }
-    let __v_8: G = G::from_u64(0);
-    let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } };
-    let __v_9: G = __r_arr[0];
-    let __v_10: G = G::from_u64(1);
-    if (__v_9 != __v_10) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_10.as_canonical_u64() });
-    }
-    let __ret: [G; OUT_717] = [];
-    record.function_queries[717].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_718: usize = 3;
-const IN_718: usize = 3;
-const OUT_718: usize = 1;
-fn aiur_fn_718(
-  inp: [G; IN_718],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_718], 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 = (__v_1 - __v_2);
-    match __v_3.as_canonical_u64() {
-      0u64 => {
-        let __v_4: G = G::from_u64(1);
-        let __ret: [G; OUT_718] = [__v_4];
-        record.function_queries[718].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        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_4: G = __loaded[0];
-        let __v_5: G = __loaded[1];
-        let __v_6: G = __loaded[2];
-        let __v_7: G = __loaded[3];
-        match __v_4.as_canonical_u64() {
-          5u64 => {
-            let __v_8: G = G::from_u64(1);
-            let __v_9: G = (__v_2 + __v_8);
-            let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_6, __v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } };
-            let __v_10: G = __r_arr[0];
-            let __ret: [G; OUT_718] = [__v_10];
-            record.function_queries[718].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_718] = [__v_8];
-            record.function_queries[718].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-        }
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_719: usize = 3;
-const IN_719: usize = 3;
-const OUT_719: usize = 0;
-fn aiur_fn_719(
-  inp: [G; IN_719],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_719], 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_684] = { let __args: [G; IN_684] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[684].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_684] = unsafe { *(result.output.as_ptr() as *const [G; OUT_684]) }; __ret } else { aiur_fn_684(__args, record, io_buffer, __cu)? } };
-    let __v_3: G = G::from_u64(0);
-    let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } };
-    let __ret: [G; OUT_719] = [];
-    record.function_queries[719].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_720: usize = 4;
-const IN_720: usize = 4;
-const OUT_720: usize = 0;
-fn aiur_fn_720(
-  inp: [G; IN_720],
+const INPUT_SIZE_645: usize = 1;
+const IN_645: usize = 1;
+const OUT_645: usize = 0;
+fn aiur_fn_645(
+  inp: [G; IN_645],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_720], ExecError> {
+) -> Result<[G; OUT_645], 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_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_4: G = __loaded[0];
-    let __v_5: G = __loaded[1];
-    let __v_6: G = __loaded[2];
-    match __v_4.as_canonical_u64() {
-      1u64 => {
-        let __ret: [G; OUT_720] = [];
-        record.function_queries[720].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].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];
-        let __v_17: G = __loaded[10];
-        let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_3, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } };
-        let __v_18: G = G::from_u64(1);
-        let __v_19: G = (__v_3 + __v_18);
-        let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_6, __v_1, __v_2, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_720] = [];
-        record.function_queries[720].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
-      },
-    }
+    let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[258].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_258] = unsafe { *(result.output.as_ptr() as *const [G; OUT_258]) }; __ret } else { aiur_fn_258(__args, record, io_buffer, __cu)? } };
+    let __v_1: G = __r_arr[0];
+    let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; 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: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].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];
+    let __v_12: G = __loaded[10];
+    let __v_13: G = __loaded[11];
+    let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__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_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[644].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_644] = unsafe { *(result.output.as_ptr() as *const [G; OUT_644]) }; __ret } else { aiur_fn_644(__args, record, io_buffer, __cu)? } };
+    let __ret: [G; OUT_645] = [];
+    record.function_queries[645].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_721: usize = 1;
-const IN_721: usize = 1;
-const OUT_721: usize = 3;
-fn aiur_fn_721(
-  inp: [G; IN_721],
+const INPUT_SIZE_646: usize = 1;
+const IN_646: usize = 1;
+const OUT_646: usize = 1;
+fn aiur_fn_646(
+  inp: [G; IN_646],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_721], ExecError> {
+) -> Result<[G; OUT_646], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[66].get_mut(&__args[..]) { 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_1: G = __r_arr[0];
-    let __v_2: G = __r_arr[1];
+    let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; 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: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].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];
     match __v_1.as_canonical_u64() {
-      0u64 => {
-        let __v_3: G = G::from_u64(1);
-        let __v_4: G = G::from_u64(1);
-        let __ret: [G; OUT_721] = [__v_3, __v_4, __v_2];
-        record.function_queries[721].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+      2u64 => {
+        let __v_19: G = G::from_u64(0);
+        let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } else { aiur_fn_15(__args, record, io_buffer, __cu)? } };
+        let __v_20: G = __r_arr[0];
+        let __v_21: G = G::from_u64(1);
+        let __v_22: G = G::from_u64(1);
+        let __v_23: G = { let __values: [G; 3] = [__v_21, __v_22, __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_19, __v_20, __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_646] = [__v_24];
+        record.function_queries[646].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      1u64 => {
-        let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[79].get_mut(&__args[..]) { 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_3: G = __r_arr[0];
-        let __v_4: G = __r_arr[1];
-        let __v_5: G = G::from_u64(0);
-        let __ret: [G; OUT_721] = [__v_5, __v_3, __v_4];
-        record.function_queries[721].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+      4u64 => {
+        let __v_19: G = G::from_u64(0);
+        let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } else { aiur_fn_15(__args, record, io_buffer, __cu)? } };
+        let __v_20: G = __r_arr[0];
+        let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } else { aiur_fn_646(__args, record, io_buffer, __cu)? } };
+        let __v_21: G = __r_arr[0];
+        let __v_22: G = { let __values: [G; 3] = [__v_19, __v_20, __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 __ret: [G; OUT_646] = [__v_22];
+        record.function_queries[646].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+      7u64 => {
+        let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } else { aiur_fn_646(__args, record, io_buffer, __cu)? } };
+        let __v_19: G = __r_arr[0];
+        let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } else { aiur_fn_646(__args, record, io_buffer, __cu)? } };
+        let __v_20: G = __r_arr[0];
+        let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[710].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_710] = unsafe { *(result.output.as_ptr() as *const [G; OUT_710]) }; __ret } else { aiur_fn_710(__args, record, io_buffer, __cu)? } };
+        let __v_21: G = __r_arr[0];
+        let __ret: [G; OUT_646] = [__v_21];
+        record.function_queries[646].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
-    }
-  })
-}
-
-const INPUT_SIZE_722: usize = 2;
-const IN_722: usize = 2;
-const OUT_722: usize = 10;
-fn aiur_fn_722(
-  inp: [G; IN_722],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_722], 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(1);
-        let __v_3: G = G::from_u64(1);
-        let __ret: [G; OUT_722] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_1];
-        record.function_queries[722].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+      8u64 => {
+        let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } else { aiur_fn_646(__args, record, io_buffer, __cu)? } };
+        let __v_19: G = __r_arr[0];
+        let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } else { aiur_fn_646(__args, record, io_buffer, __cu)? } };
+        let __v_20: G = __r_arr[0];
+        let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[710].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_710] = unsafe { *(result.output.as_ptr() as *const [G; OUT_710]) }; __ret } else { aiur_fn_710(__args, record, io_buffer, __cu)? } };
+        let __v_21: G = __r_arr[0];
+        let __ret: [G; OUT_646] = [__v_21];
+        record.function_queries[646].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      9u64 => {
+        let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } else { aiur_fn_646(__args, record, io_buffer, __cu)? } };
+        let __v_19: G = __r_arr[0];
+        let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } else { aiur_fn_646(__args, record, io_buffer, __cu)? } };
+        let __v_20: G = __r_arr[0];
+        let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[710].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_710] = unsafe { *(result.output.as_ptr() as *const [G; OUT_710]) }; __ret } else { aiur_fn_710(__args, record, io_buffer, __cu)? } };
+        let __v_21: G = __r_arr[0];
+        let __ret: [G; OUT_646] = [__v_21];
+        record.function_queries[646].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      10u64 => {
+        let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } else { aiur_fn_646(__args, record, io_buffer, __cu)? } };
+        let __v_19: G = __r_arr[0];
+        let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } else { aiur_fn_646(__args, record, io_buffer, __cu)? } };
+        let __v_20: G = __r_arr[0];
+        let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } else { aiur_fn_646(__args, record, io_buffer, __cu)? } };
+        let __v_21: G = __r_arr[0];
+        let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_20, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[710].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_710] = unsafe { *(result.output.as_ptr() as *const [G; OUT_710]) }; __ret } else { aiur_fn_710(__args, record, io_buffer, __cu)? } };
+        let __v_22: G = __r_arr[0];
+        let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_19, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[710].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_710] = unsafe { *(result.output.as_ptr() as *const [G; OUT_710]) }; __ret } else { aiur_fn_710(__args, record, io_buffer, __cu)? } };
+        let __v_23: G = __r_arr[0];
+        let __ret: [G; OUT_646] = [__v_23];
+        record.function_queries[646].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { 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_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(0);
-        let __ret: [G; OUT_722] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10];
-        record.function_queries[722].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __v_19: G = G::from_u64(1);
+        let __v_20: G = G::from_u64(1);
+        let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __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 __ret: [G; OUT_646] = [__v_21];
+        record.function_queries[646].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_723: usize = 2;
-const IN_723: usize = 2;
-const OUT_723: usize = 3;
-fn aiur_fn_723(
-  inp: [G; IN_723],
+const INPUT_SIZE_647: usize = 1;
+const IN_647: usize = 1;
+const OUT_647: usize = 1;
+fn aiur_fn_647(
+  inp: [G; IN_647],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_723], ExecError> {
+) -> Result<[G; OUT_647], 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() {
+    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(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_647] = [__v_6];
+        record.function_queries[647].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
       0u64 => {
-        let __v_2: G = G::from_u64(1);
-        let __v_3: G = G::from_u64(1);
-        let __ret: [G; OUT_723] = [__v_2, __v_3, __v_1];
-        record.function_queries[723].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } else { aiur_fn_646(__args, record, io_buffer, __cu)? } };
+        let __v_4: G = __r_arr[0];
+        let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[647].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_647] = unsafe { *(result.output.as_ptr() as *const [G; OUT_647]) }; __ret } else { aiur_fn_647(__args, record, io_buffer, __cu)? } };
+        let __v_5: G = __r_arr[0];
+        let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[710].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_710] = unsafe { *(result.output.as_ptr() as *const [G; OUT_710]) }; __ret } else { aiur_fn_710(__args, record, io_buffer, __cu)? } };
+        let __v_6: G = __r_arr[0];
+        let __ret: [G; OUT_647] = [__v_6];
+        record.function_queries[647].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[79].get_mut(&__args[..]) { 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 = G::from_u64(0);
-        let __ret: [G; OUT_723] = [__v_4, __v_2, __v_3];
-        record.function_queries[723].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_724: usize = 2;
-const IN_724: usize = 2;
-const OUT_724: usize = 3;
-fn aiur_fn_724(
-  inp: [G; IN_724],
+const INPUT_SIZE_648: usize = 1;
+const IN_648: usize = 1;
+const OUT_648: usize = 1;
+fn aiur_fn_648(
+  inp: [G; IN_648],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_724], ExecError> {
+) -> Result<[G; OUT_648], 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(1);
-        let __v_3: G = G::from_u64(1);
-        let __ret: [G; OUT_724] = [__v_2, __v_3, __v_1];
-        record.function_queries[724].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].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];
+    match __v_1.as_canonical_u64() {
+      1u64 => {
+        let __v_12: G = G::from_u64(1);
+        let __v_13: G = G::from_u64(1);
+        let __v_14: G = { let __values: [G; 3] = [__v_12, __v_13, __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 __ret: [G; OUT_648] = [__v_14];
+        record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
+      0u64 => {
+        match __v_2.as_canonical_u64() {
+          _ => {
+            let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } else { aiur_fn_646(__args, record, io_buffer, __cu)? } };
+            let __v_12: G = __r_arr[0];
+            let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[648].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_648] = unsafe { *(result.output.as_ptr() as *const [G; OUT_648]) }; __ret } else { aiur_fn_648(__args, record, io_buffer, __cu)? } };
+            let __v_13: G = __r_arr[0];
+            let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[710].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_710] = unsafe { *(result.output.as_ptr() as *const [G; OUT_710]) }; __ret } else { aiur_fn_710(__args, record, io_buffer, __cu)? } };
+            let __v_14: G = __r_arr[0];
+            let __ret: [G; OUT_648] = [__v_14];
+            record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+        }
+      },
       _ => {
-        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 !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_2: G = __r_arr[0];
-        let __v_3: G = __r_arr[1];
-        let __v_4: G = G::from_u64(0);
-        let __ret: [G; OUT_724] = [__v_4, __v_2, __v_3];
-        record.function_queries[724].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_725: usize = 2;
-const IN_725: usize = 2;
-const OUT_725: usize = 3;
-fn aiur_fn_725(
-  inp: [G; IN_725],
+const INPUT_SIZE_649: usize = 1;
+const IN_649: usize = 1;
+const OUT_649: usize = 1;
+fn aiur_fn_649(
+  inp: [G; IN_649],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_725], ExecError> {
+) -> Result<[G; OUT_649], 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(1);
-        let __v_3: G = G::from_u64(1);
-        let __ret: [G; OUT_725] = [__v_2, __v_3, __v_1];
-        record.function_queries[725].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __loaded: [G; 36] = { let __mq = record.memory_queries.get_mut(&36).ok_or(ExecError::InvalidMemorySize(36))?; 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: 36 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 36] = __args[..36].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 __v_35: G = __loaded[34];
+    let __v_36: G = __loaded[35];
+    match __v_1.as_canonical_u64() {
+      1u64 => {
+        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 __ret: [G; OUT_649] = [__v_39];
+        record.function_queries[649].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      _ => {
-        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 !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_2: G = __r_arr[0];
-        let __v_3: G = __r_arr[1];
+      0u64 => {
         match __v_2.as_canonical_u64() {
-          0u64 => {
-            let __v_4: G = G::from_u64(0);
-            let __v_5: G = G::from_u64(0);
-            let __ret: [G; OUT_725] = [__v_4, __v_5, __v_3];
-            record.function_queries[725].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 __ret: [G; OUT_725] = [__v_4, __v_5, __v_3];
-            record.function_queries[725].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          2u64 => {
-            let __v_4: G = G::from_u64(0);
-            let __v_5: G = G::from_u64(2);
-            let __ret: [G; OUT_725] = [__v_4, __v_5, __v_3];
-            record.function_queries[725].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+            let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } else { aiur_fn_646(__args, record, io_buffer, __cu)? } };
+            let __v_37: G = __r_arr[0];
+            let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[649].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_649] = unsafe { *(result.output.as_ptr() as *const [G; OUT_649]) }; __ret } else { aiur_fn_649(__args, record, io_buffer, __cu)? } };
+            let __v_38: G = __r_arr[0];
+            let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[710].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_710] = unsafe { *(result.output.as_ptr() as *const [G; OUT_710]) }; __ret } else { aiur_fn_710(__args, record, io_buffer, __cu)? } };
+            let __v_39: G = __r_arr[0];
+            let __ret: [G; OUT_649] = [__v_39];
+            record.function_queries[649].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
           },
         }
       },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+      },
     }
   })
 }
 
-const INPUT_SIZE_726: usize = 2;
-const IN_726: usize = 2;
-const OUT_726: usize = 3;
-fn aiur_fn_726(
-  inp: [G; IN_726],
+const INPUT_SIZE_650: usize = 1;
+const IN_650: usize = 1;
+const OUT_650: usize = 1;
+fn aiur_fn_650(
+  inp: [G; IN_650],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_726], ExecError> {
+) -> Result<[G; OUT_650], 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(1);
-        let __v_3: G = G::from_u64(1);
-        let __ret: [G; OUT_726] = [__v_2, __v_3, __v_1];
-        record.function_queries[726].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; 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: 47 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 47] = __args[..47].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 __v_35: G = __loaded[34];
+    let __v_36: G = __loaded[35];
+    let __v_37: G = __loaded[36];
+    let __v_38: G = __loaded[37];
+    let __v_39: G = __loaded[38];
+    let __v_40: G = __loaded[39];
+    let __v_41: G = __loaded[40];
+    let __v_42: G = __loaded[41];
+    let __v_43: G = __loaded[42];
+    let __v_44: G = __loaded[43];
+    let __v_45: G = __loaded[44];
+    let __v_46: G = __loaded[45];
+    let __v_47: G = __loaded[46];
+    match __v_1.as_canonical_u64() {
+      1u64 => {
+        let __v_48: G = G::from_u64(1);
+        let __v_49: G = G::from_u64(1);
+        let __v_50: G = { let __values: [G; 3] = [__v_48, __v_49, __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 __ret: [G; OUT_650] = [__v_50];
+        record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      _ => {
-        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 !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_2: G = __r_arr[0];
-        let __v_3: G = __r_arr[1];
+      0u64 => {
         match __v_2.as_canonical_u64() {
           0u64 => {
-            let __v_4: G = G::from_u64(0);
-            let __v_5: G = G::from_u64(0);
-            let __ret: [G; OUT_726] = [__v_4, __v_5, __v_3];
-            record.function_queries[726].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
+            match __v_3.as_canonical_u64() {
+              _ => {
+                let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } else { aiur_fn_646(__args, record, io_buffer, __cu)? } };
+                let __v_48: G = __r_arr[0];
+                let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } else { aiur_fn_646(__args, record, io_buffer, __cu)? } };
+                let __v_49: G = __r_arr[0];
+                let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[710].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_710] = unsafe { *(result.output.as_ptr() as *const [G; OUT_710]) }; __ret } else { aiur_fn_710(__args, record, io_buffer, __cu)? } };
+                let __v_50: G = __r_arr[0];
+                let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[650].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_650] = unsafe { *(result.output.as_ptr() as *const [G; OUT_650]) }; __ret } else { aiur_fn_650(__args, record, io_buffer, __cu)? } };
+                let __v_51: G = __r_arr[0];
+                let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_50, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[710].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_710] = unsafe { *(result.output.as_ptr() as *const [G; OUT_710]) }; __ret } else { aiur_fn_710(__args, record, io_buffer, __cu)? } };
+                let __v_52: G = __r_arr[0];
+                let __ret: [G; OUT_650] = [__v_52];
+                record.function_queries[650].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 __ret: [G; OUT_726] = [__v_4, __v_5, __v_3];
-            record.function_queries[726].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
+            match __v_3.as_canonical_u64() {
+              _ => {
+                let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } else { aiur_fn_646(__args, record, io_buffer, __cu)? } };
+                let __v_48: G = __r_arr[0];
+                let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[649].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_649] = unsafe { *(result.output.as_ptr() as *const [G; OUT_649]) }; __ret } else { aiur_fn_649(__args, record, io_buffer, __cu)? } };
+                let __v_49: G = __r_arr[0];
+                let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[710].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_710] = unsafe { *(result.output.as_ptr() as *const [G; OUT_710]) }; __ret } else { aiur_fn_710(__args, record, io_buffer, __cu)? } };
+                let __v_50: G = __r_arr[0];
+                let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[650].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_650] = unsafe { *(result.output.as_ptr() as *const [G; OUT_650]) }; __ret } else { aiur_fn_650(__args, record, io_buffer, __cu)? } };
+                let __v_51: G = __r_arr[0];
+                let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_50, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[710].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_710] = unsafe { *(result.output.as_ptr() as *const [G; OUT_710]) }; __ret } else { aiur_fn_710(__args, record, io_buffer, __cu)? } };
+                let __v_52: G = __r_arr[0];
+                let __ret: [G; OUT_650] = [__v_52];
+                record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+            }
           },
           2u64 => {
-            let __v_4: G = G::from_u64(0);
-            let __v_5: G = G::from_u64(2);
-            let __ret: [G; OUT_726] = [__v_4, __v_5, __v_3];
-            record.function_queries[726].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          3u64 => {
-            let __v_4: G = G::from_u64(0);
-            let __v_5: G = G::from_u64(3);
-            let __ret: [G; OUT_726] = [__v_4, __v_5, __v_3];
-            record.function_queries[726].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
+            match __v_3.as_canonical_u64() {
+              _ => {
+                let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } else { aiur_fn_646(__args, record, io_buffer, __cu)? } };
+                let __v_48: G = __r_arr[0];
+                let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[648].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_648] = unsafe { *(result.output.as_ptr() as *const [G; OUT_648]) }; __ret } else { aiur_fn_648(__args, record, io_buffer, __cu)? } };
+                let __v_49: G = __r_arr[0];
+                let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[710].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_710] = unsafe { *(result.output.as_ptr() as *const [G; OUT_710]) }; __ret } else { aiur_fn_710(__args, record, io_buffer, __cu)? } };
+                let __v_50: G = __r_arr[0];
+                let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[650].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_650] = unsafe { *(result.output.as_ptr() as *const [G; OUT_650]) }; __ret } else { aiur_fn_650(__args, record, io_buffer, __cu)? } };
+                let __v_51: G = __r_arr[0];
+                let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_50, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[710].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_710] = unsafe { *(result.output.as_ptr() as *const [G; OUT_710]) }; __ret } else { aiur_fn_710(__args, record, io_buffer, __cu)? } };
+                let __v_52: G = __r_arr[0];
+                let __ret: [G; OUT_650] = [__v_52];
+                record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+            }
           },
           _ => {
             return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
           },
         }
       },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+      },
     }
   })
 }
 
-const INPUT_SIZE_727: usize = 9;
-const IN_727: usize = 9;
-const OUT_727: usize = 2;
-fn aiur_fn_727(
-  inp: [G; IN_727],
+const INPUT_SIZE_651: usize = 48;
+const IN_651: usize = 48;
+const OUT_651: usize = 1;
+fn aiur_fn_651(
+  inp: [G; IN_651],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_727], ExecError> {
+) -> Result<[G; OUT_651], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -60433,114 +53287,190 @@ fn aiur_fn_727(
     let __v_6: G = inp[6];
     let __v_7: G = inp[7];
     let __v_8: G = inp[8];
-    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__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[2].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
-    let __v_9: G = __r_arr[0];
-    match __v_9.as_canonical_u64() {
-      1u64 => {
-        let __v_10: G = G::from_u64(1);
-        let __v_11: G = G::from_u64(1);
-        let __v_12: G = { let __values: [G; 19] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&19).ok_or(ExecError::InvalidMemorySize(19))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_727] = [__v_12, __v_0];
-        record.function_queries[727].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
+    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];
+    match __v_0.as_canonical_u64() {
       _ => {
-        let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[98].get_mut(&__args[..]) { 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_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 = __r_arr[9];
-        let __v_20: G = __r_arr[10];
-        let __v_21: G = __r_arr[11];
-        let __v_22: G = __r_arr[12];
-        let __v_23: G = __r_arr[13];
-        let __v_24: G = __r_arr[14];
-        let __v_25: G = __r_arr[15];
-        let __v_26: G = __r_arr[16];
-        let __v_27: G = __r_arr[17];
-        let __r_arr: [G; OUT_12] = { let __args: [G; IN_12] = [__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[12].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_12] = unsafe { *(result.output.as_ptr() as *const [G; OUT_12]) }; __ret } else { aiur_fn_12(__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 __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[727].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_727] = unsafe { *(result.output.as_ptr() as *const [G; OUT_727]) }; __ret } else { aiur_fn_727(__args, record, io_buffer, __cu)? } };
-        let __v_36: G = __r_arr[0];
-        let __v_37: G = __r_arr[1];
-        let __v_38: G = G::from_u64(0);
-        let __v_39: G = { let __values: [G; 19] = [__v_38, __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_36]; let __mq = record.memory_queries.get_mut(&19).ok_or(ExecError::InvalidMemorySize(19))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_727] = [__v_39, __v_37];
-        record.function_queries[727].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
+        let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[647].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_647] = unsafe { *(result.output.as_ptr() as *const [G; OUT_647]) }; __ret } else { aiur_fn_647(__args, record, io_buffer, __cu)? } };
+        let __v_48: G = __r_arr[0];
+        match __v_0.as_canonical_u64() {
+          0u64 => {
+            match __v_1.as_canonical_u64() {
+              _ => {
+                let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } else { aiur_fn_646(__args, record, io_buffer, __cu)? } };
+                let __v_49: G = __r_arr[0];
+                let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } else { aiur_fn_646(__args, record, io_buffer, __cu)? } };
+                let __v_50: G = __r_arr[0];
+                let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[710].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_710] = unsafe { *(result.output.as_ptr() as *const [G; OUT_710]) }; __ret } else { aiur_fn_710(__args, record, io_buffer, __cu)? } };
+                let __v_51: G = __r_arr[0];
+                let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_48, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[710].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_710] = unsafe { *(result.output.as_ptr() as *const [G; OUT_710]) }; __ret } else { aiur_fn_710(__args, record, io_buffer, __cu)? } };
+                let __v_52: G = __r_arr[0];
+                let __ret: [G; OUT_651] = [__v_52];
+                record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+            }
+          },
+          1u64 => {
+            match __v_1.as_canonical_u64() {
+              _ => {
+                let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } else { aiur_fn_646(__args, record, io_buffer, __cu)? } };
+                let __v_49: G = __r_arr[0];
+                let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[648].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_648] = unsafe { *(result.output.as_ptr() as *const [G; OUT_648]) }; __ret } else { aiur_fn_648(__args, record, io_buffer, __cu)? } };
+                let __v_50: G = __r_arr[0];
+                let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[710].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_710] = unsafe { *(result.output.as_ptr() as *const [G; OUT_710]) }; __ret } else { aiur_fn_710(__args, record, io_buffer, __cu)? } };
+                let __v_51: G = __r_arr[0];
+                let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_48, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[710].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_710] = unsafe { *(result.output.as_ptr() as *const [G; OUT_710]) }; __ret } else { aiur_fn_710(__args, record, io_buffer, __cu)? } };
+                let __v_52: G = __r_arr[0];
+                let __ret: [G; OUT_651] = [__v_52];
+                record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+            }
+          },
+          2u64 => {
+            match __v_1.as_canonical_u64() {
+              _ => {
+                let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } else { aiur_fn_646(__args, record, io_buffer, __cu)? } };
+                let __v_49: G = __r_arr[0];
+                let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[710].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_710] = unsafe { *(result.output.as_ptr() as *const [G; OUT_710]) }; __ret } else { aiur_fn_710(__args, record, io_buffer, __cu)? } };
+                let __v_50: G = __r_arr[0];
+                let __ret: [G; OUT_651] = [__v_50];
+                record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+            }
+          },
+          3u64 => {
+            match __v_1.as_canonical_u64() {
+              _ => {
+                let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } else { aiur_fn_646(__args, record, io_buffer, __cu)? } };
+                let __v_49: G = __r_arr[0];
+                let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[710].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_710] = unsafe { *(result.output.as_ptr() as *const [G; OUT_710]) }; __ret } else { aiur_fn_710(__args, record, io_buffer, __cu)? } };
+                let __v_50: G = __r_arr[0];
+                let __ret: [G; OUT_651] = [__v_50];
+                record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+            }
+          },
+          8u64 => {
+            let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[650].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_650] = unsafe { *(result.output.as_ptr() as *const [G; OUT_650]) }; __ret } else { aiur_fn_650(__args, record, io_buffer, __cu)? } };
+            let __v_49: G = __r_arr[0];
+            let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[710].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_710] = unsafe { *(result.output.as_ptr() as *const [G; OUT_710]) }; __ret } else { aiur_fn_710(__args, record, io_buffer, __cu)? } };
+            let __v_50: G = __r_arr[0];
+            let __ret: [G; OUT_651] = [__v_50];
+            record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            let __ret: [G; OUT_651] = [__v_48];
+            record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+        }
       },
     }
   })
 }
 
-const INPUT_SIZE_728: usize = 2;
-const IN_728: usize = 2;
-const OUT_728: usize = 3;
-fn aiur_fn_728(
-  inp: [G; IN_728],
+const INPUT_SIZE_652: usize = 2;
+const IN_652: usize = 2;
+const OUT_652: usize = 1;
+fn aiur_fn_652(
+  inp: [G; IN_652],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_728], ExecError> {
+) -> Result<[G; OUT_652], 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(1);
-        let __v_3: G = G::from_u64(1);
-        let __ret: [G; OUT_728] = [__v_2, __v_3, __v_1];
-        record.function_queries[728].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_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_652] = [__v_5];
+        record.function_queries[652].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
+      0u64 => {
+        let __v_5: G = (__v_3 - __v_1);
+        match __v_5.as_canonical_u64() {
+          0u64 => {
+            let __v_6: G = G::from_u64(1);
+            let __ret: [G; OUT_652] = [__v_6];
+            record.function_queries[652].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = unsafe { *(result.output.as_ptr() as *const [G; OUT_652]) }; __ret } else { aiur_fn_652(__args, record, io_buffer, __cu)? } };
+            let __v_6: G = __r_arr[0];
+            let __ret: [G; OUT_652] = [__v_6];
+            record.function_queries[652].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+        }
+      },
       _ => {
-        let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { 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_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_727] = { let __args: [G; IN_727] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[727].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_727] = unsafe { *(result.output.as_ptr() as *const [G; OUT_727]) }; __ret } else { aiur_fn_727(__args, record, io_buffer, __cu)? } };
-        let __v_11: G = __r_arr[0];
-        let __v_12: G = __r_arr[1];
-        let __v_13: G = G::from_u64(0);
-        let __ret: [G; OUT_728] = [__v_13, __v_11, __v_12];
-        record.function_queries[728].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_729: usize = 1;
-const IN_729: usize = 1;
-const OUT_729: usize = 41;
-fn aiur_fn_729(
-  inp: [G; IN_729],
+const INPUT_SIZE_653: usize = 1;
+const IN_653: usize = 1;
+const OUT_653: usize = 0;
+fn aiur_fn_653(
+  inp: [G; IN_653],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_729], ExecError> {
+) -> Result<[G; OUT_653], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } else { aiur_fn_255(__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];
@@ -60550,492 +53480,466 @@ fn aiur_fn_729(
     let __v_7: G = __r_arr[6];
     let __v_8: G = __r_arr[7];
     let __v_9: G = __r_arr[8];
-    let __b1_out: [G; 8] = if unconstrained { let __v: Vec<G> = Bytes1::bit_decompose(&__v_1); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_1, record) };
-    let __v_10: G = __b1_out[0];
-    let __v_11: G = __b1_out[1];
-    let __v_12: G = __b1_out[2];
-    let __v_13: G = __b1_out[3];
-    let __v_14: G = __b1_out[4];
-    let __v_15: G = __b1_out[5];
-    let __v_16: G = __b1_out[6];
-    let __v_17: G = __b1_out[7];
-    let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_10, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[724].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_724] = unsafe { *(result.output.as_ptr() as *const [G; OUT_724]) }; __ret } else { aiur_fn_724(__args, record, io_buffer, __cu)? } };
-    let __v_18: G = __r_arr[0];
-    let __v_19: G = __r_arr[1];
-    let __v_20: G = __r_arr[2];
-    let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_11, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__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_722] = { let __args: [G; IN_722] = [__v_12, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__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_722] = { let __args: [G; IN_722] = [__v_13, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__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_722] = { let __args: [G; IN_722] = [__v_14, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__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_723] = { let __args: [G; IN_723] = [__v_15, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[723].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_723] = unsafe { *(result.output.as_ptr() as *const [G; OUT_723]) }; __ret } else { aiur_fn_723(__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 __ret: [G; OUT_729] = [__v_18, __v_19, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_61, __v_62, __v_63];
-    record.function_queries[729].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
+    let __v_10: G = __r_arr[9];
+    let __v_11: G = __r_arr[10];
+    let __v_12: G = __r_arr[11];
+    let __v_13: G = __r_arr[12];
+    let __v_14: G = __r_arr[13];
+    let __v_15: G = __r_arr[14];
+    let __v_16: G = __r_arr[15];
+    let __v_17: G = __r_arr[16];
+    let __v_18: G = __r_arr[17];
+    let __v_19: G = __r_arr[18];
+    let __v_20: G = __r_arr[19];
+    let __v_21: G = __r_arr[20];
+    let __v_22: G = __r_arr[21];
+    let __v_23: G = __r_arr[22];
+    let __v_24: G = __r_arr[23];
+    let __v_25: G = __r_arr[24];
+    let __v_26: G = __r_arr[25];
+    let __v_27: G = __r_arr[26];
+    let __v_28: G = __r_arr[27];
+    let __v_29: G = __r_arr[28];
+    let __v_30: G = __r_arr[29];
+    let __v_31: G = __r_arr[30];
+    let __v_32: G = __r_arr[31];
+    let __v_33: G = __r_arr[32];
+    let __v_34: G = __r_arr[33];
+    let __v_35: G = __r_arr[34];
+    let __v_36: G = __r_arr[35];
+    let __v_37: G = __r_arr[36];
+    let __v_38: G = __r_arr[37];
+    let __v_39: G = __r_arr[38];
+    let __v_40: G = __r_arr[39];
+    let __v_41: G = __r_arr[40];
+    let __v_42: G = __r_arr[41];
+    let __v_43: G = __r_arr[42];
+    let __v_44: G = __r_arr[43];
+    let __v_45: G = __r_arr[44];
+    let __v_46: G = __r_arr[45];
+    let __v_47: G = __r_arr[46];
+    let __v_48: G = __r_arr[47];
+    match __v_1.as_canonical_u64() {
+      _ => {
+        let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_1.as_canonical_u64() {
+  8u64 => {
+    let __v_49: G = G::from_u64(0);
+    let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_0, __v_2, __v_2, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[655].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_655] = unsafe { *(result.output.as_ptr() as *const [G; OUT_655]) }; __ret } else { aiur_fn_655(__args, record, io_buffer, __cu)? } };
+    break '__mc_0 [];
+  },
+  7u64 => {
+    match __v_2.as_canonical_u64() {
+      _ => {
+        let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = unsafe { *(result.output.as_ptr() as *const [G; OUT_645]) }; __ret } else { aiur_fn_645(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[653].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_653] = unsafe { *(result.output.as_ptr() as *const [G; OUT_653]) }; __ret } else { aiur_fn_653(__args, record, io_buffer, __cu)? } };
+        break '__mc_0 [];
+      },
+    }
+  },
+  6u64 => {
+    match __v_2.as_canonical_u64() {
+      _ => {
+        let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = unsafe { *(result.output.as_ptr() as *const [G; OUT_645]) }; __ret } else { aiur_fn_645(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[653].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_653] = unsafe { *(result.output.as_ptr() as *const [G; OUT_653]) }; __ret } else { aiur_fn_653(__args, record, io_buffer, __cu)? } };
+        break '__mc_0 [];
+      },
+    }
+  },
+  4u64 => {
+    match __v_2.as_canonical_u64() {
+      _ => {
+        let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = unsafe { *(result.output.as_ptr() as *const [G; OUT_645]) }; __ret } else { aiur_fn_645(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[653].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_653] = unsafe { *(result.output.as_ptr() as *const [G; OUT_653]) }; __ret } else { aiur_fn_653(__args, record, io_buffer, __cu)? } };
+        break '__mc_0 [];
+      },
+    }
+  },
+  5u64 => {
+    match __v_2.as_canonical_u64() {
+      _ => {
+        let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = unsafe { *(result.output.as_ptr() as *const [G; OUT_645]) }; __ret } else { aiur_fn_645(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[653].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_653] = unsafe { *(result.output.as_ptr() as *const [G; OUT_653]) }; __ret } else { aiur_fn_653(__args, record, io_buffer, __cu)? } };
+        break '__mc_0 [];
+      },
+    }
+  },
+  _ => {
+    let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = unsafe { *(result.output.as_ptr() as *const [G; OUT_645]) }; __ret } else { aiur_fn_645(__args, record, io_buffer, __cu)? } };
+    break '__mc_0 [];
+  },
+}
+ };
+        let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = [__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_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]; let __cu = unconstrained; if let Some(result) = record.function_queries[651].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_651] = unsafe { *(result.output.as_ptr() as *const [G; OUT_651]) }; __ret } else { aiur_fn_651(__args, record, io_buffer, __cu)? } };
+        let __v_49: G = __r_arr[0];
+        let __v_50: G = G::from_u64(0);
+        let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_47, __v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = unsafe { *(result.output.as_ptr() as *const [G; OUT_654]) }; __ret } else { aiur_fn_654(__args, record, io_buffer, __cu)? } };
+        let __ret: [G; OUT_653] = [];
+        record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+    }
   })
 }
 
-const INPUT_SIZE_730: usize = 1;
-const IN_730: usize = 1;
-const OUT_730: usize = 49;
-fn aiur_fn_730(
-  inp: [G; IN_730],
+const INPUT_SIZE_654: usize = 3;
+const IN_654: usize = 3;
+const OUT_654: usize = 0;
+fn aiur_fn_654(
+  inp: [G; IN_654],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_730], ExecError> {
+) -> Result<[G; OUT_654], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { 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_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_729] = { let __args: [G; IN_729] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[729].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_729] = unsafe { *(result.output.as_ptr() as *const [G; OUT_729]) }; __ret } else { aiur_fn_729(__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 = __r_arr[9];
-    let __v_20: G = __r_arr[10];
-    let __v_21: G = __r_arr[11];
-    let __v_22: G = __r_arr[12];
-    let __v_23: G = __r_arr[13];
-    let __v_24: G = __r_arr[14];
-    let __v_25: G = __r_arr[15];
-    let __v_26: G = __r_arr[16];
-    let __v_27: G = __r_arr[17];
-    let __v_28: G = __r_arr[18];
-    let __v_29: G = __r_arr[19];
-    let __v_30: G = __r_arr[20];
-    let __v_31: G = __r_arr[21];
-    let __v_32: G = __r_arr[22];
-    let __v_33: G = __r_arr[23];
-    let __v_34: G = __r_arr[24];
-    let __v_35: G = __r_arr[25];
-    let __v_36: G = __r_arr[26];
-    let __v_37: G = __r_arr[27];
-    let __v_38: G = __r_arr[28];
-    let __v_39: G = __r_arr[29];
-    let __v_40: G = __r_arr[30];
-    let __v_41: G = __r_arr[31];
-    let __v_42: G = __r_arr[32];
-    let __v_43: G = __r_arr[33];
-    let __v_44: G = __r_arr[34];
-    let __v_45: G = __r_arr[35];
-    let __v_46: G = __r_arr[36];
-    let __v_47: G = __r_arr[37];
-    let __v_48: G = __r_arr[38];
-    let __v_49: G = __r_arr[39];
-    let __v_50: G = __r_arr[40];
-    let __ret: [G; OUT_730] = [__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_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];
-    record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
+    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 __ret: [G; OUT_654] = [];
+        record.function_queries[654].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = unsafe { *(result.output.as_ptr() as *const [G; OUT_652]) }; __ret } else { aiur_fn_652(__args, record, io_buffer, __cu)? } };
+        let __v_6: G = __r_arr[0];
+        let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_6.as_canonical_u64() {
+  1u64 => {
+    let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[653].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_653] = unsafe { *(result.output.as_ptr() as *const [G; OUT_653]) }; __ret } else { aiur_fn_653(__args, record, io_buffer, __cu)? } };
+    break '__mc_0 [];
+  },
+  _ => {
+    break '__mc_0 [];
+  },
+}
+ };
+        let __v_7: G = G::from_u64(1);
+        let __v_8: G = (__v_2 + __v_7);
+        let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_5, __v_1, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = unsafe { *(result.output.as_ptr() as *const [G; OUT_654]) }; __ret } else { aiur_fn_654(__args, record, io_buffer, __cu)? } };
+        let __ret: [G; OUT_654] = [];
+        record.function_queries[654].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
+      },
+    }
   })
 }
 
-const INPUT_SIZE_731: usize = 9;
-const IN_731: usize = 9;
-const OUT_731: usize = 2;
-fn aiur_fn_731(
-  inp: [G; IN_731],
+const INPUT_SIZE_655: usize = 4;
+const IN_655: usize = 4;
+const OUT_655: usize = 0;
+fn aiur_fn_655(
+  inp: [G; IN_655],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_731], ExecError> {
+) -> Result<[G; OUT_655], 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_2] = { let __args: [G; IN_2] = [__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[2].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
-    let __v_9: G = __r_arr[0];
-    match __v_9.as_canonical_u64() {
+    let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; 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: 47 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr };
+    let __v_4: G = __loaded[0];
+    let __v_5: G = __loaded[1];
+    let __v_6: G = __loaded[2];
+    let __v_7: G = __loaded[3];
+    let __v_8: G = __loaded[4];
+    let __v_9: G = __loaded[5];
+    let __v_10: G = __loaded[6];
+    let __v_11: G = __loaded[7];
+    let __v_12: G = __loaded[8];
+    let __v_13: G = __loaded[9];
+    let __v_14: G = __loaded[10];
+    let __v_15: G = __loaded[11];
+    let __v_16: G = __loaded[12];
+    let __v_17: G = __loaded[13];
+    let __v_18: G = __loaded[14];
+    let __v_19: G = __loaded[15];
+    let __v_20: G = __loaded[16];
+    let __v_21: G = __loaded[17];
+    let __v_22: G = __loaded[18];
+    let __v_23: G = __loaded[19];
+    let __v_24: G = __loaded[20];
+    let __v_25: G = __loaded[21];
+    let __v_26: G = __loaded[22];
+    let __v_27: G = __loaded[23];
+    let __v_28: G = __loaded[24];
+    let __v_29: G = __loaded[25];
+    let __v_30: G = __loaded[26];
+    let __v_31: G = __loaded[27];
+    let __v_32: G = __loaded[28];
+    let __v_33: G = __loaded[29];
+    let __v_34: G = __loaded[30];
+    let __v_35: G = __loaded[31];
+    let __v_36: G = __loaded[32];
+    let __v_37: G = __loaded[33];
+    let __v_38: G = __loaded[34];
+    let __v_39: G = __loaded[35];
+    let __v_40: G = __loaded[36];
+    let __v_41: G = __loaded[37];
+    let __v_42: G = __loaded[38];
+    let __v_43: G = __loaded[39];
+    let __v_44: G = __loaded[40];
+    let __v_45: G = __loaded[41];
+    let __v_46: G = __loaded[42];
+    let __v_47: G = __loaded[43];
+    let __v_48: G = __loaded[44];
+    let __v_49: G = __loaded[45];
+    let __v_50: G = __loaded[46];
+    match __v_4.as_canonical_u64() {
       1u64 => {
-        let __v_10: G = G::from_u64(1);
-        let __v_11: G = G::from_u64(1);
-        let __v_12: G = { let __values: [G; 50] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&50).ok_or(ExecError::InvalidMemorySize(50))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_731] = [__v_12, __v_0];
-        record.function_queries[731].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_655] = [];
+        record.function_queries[655].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      _ => {
-        let __r_arr: [G; OUT_730] = { let __args: [G; IN_730] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[730].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_730] = unsafe { *(result.output.as_ptr() as *const [G; OUT_730]) }; __ret } else { aiur_fn_730(__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 = __r_arr[9];
-        let __v_20: G = __r_arr[10];
-        let __v_21: G = __r_arr[11];
-        let __v_22: G = __r_arr[12];
-        let __v_23: G = __r_arr[13];
-        let __v_24: G = __r_arr[14];
-        let __v_25: G = __r_arr[15];
-        let __v_26: G = __r_arr[16];
-        let __v_27: G = __r_arr[17];
-        let __v_28: G = __r_arr[18];
-        let __v_29: G = __r_arr[19];
-        let __v_30: G = __r_arr[20];
-        let __v_31: G = __r_arr[21];
-        let __v_32: G = __r_arr[22];
-        let __v_33: G = __r_arr[23];
-        let __v_34: G = __r_arr[24];
-        let __v_35: G = __r_arr[25];
-        let __v_36: G = __r_arr[26];
-        let __v_37: G = __r_arr[27];
-        let __v_38: G = __r_arr[28];
-        let __v_39: G = __r_arr[29];
-        let __v_40: G = __r_arr[30];
-        let __v_41: G = __r_arr[31];
-        let __v_42: G = __r_arr[32];
-        let __v_43: G = __r_arr[33];
-        let __v_44: G = __r_arr[34];
-        let __v_45: G = __r_arr[35];
-        let __v_46: G = __r_arr[36];
-        let __v_47: G = __r_arr[37];
-        let __v_48: G = __r_arr[38];
-        let __v_49: G = __r_arr[39];
-        let __v_50: G = __r_arr[40];
-        let __v_51: G = __r_arr[41];
-        let __v_52: G = __r_arr[42];
-        let __v_53: G = __r_arr[43];
-        let __v_54: G = __r_arr[44];
-        let __v_55: G = __r_arr[45];
-        let __v_56: G = __r_arr[46];
-        let __v_57: G = __r_arr[47];
-        let __v_58: G = __r_arr[48];
-        let __r_arr: [G; OUT_12] = { let __args: [G; IN_12] = [__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[12].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_12] = unsafe { *(result.output.as_ptr() as *const [G; OUT_12]) }; __ret } else { aiur_fn_12(__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 __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66]; let __cu = unconstrained; if let Some(result) = record.function_queries[731].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_731] = unsafe { *(result.output.as_ptr() as *const [G; OUT_731]) }; __ret } else { aiur_fn_731(__args, record, io_buffer, __cu)? } };
-        let __v_67: G = __r_arr[0];
-        let __v_68: G = __r_arr[1];
-        let __v_69: G = G::from_u64(0);
-        let __v_70: G = { let __values: [G; 50] = [__v_69, __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_67]; let __mq = record.memory_queries.get_mut(&50).ok_or(ExecError::InvalidMemorySize(50))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_731] = [__v_70, __v_68];
-        record.function_queries[731].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+      0u64 => {
+        let __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = [__v_0, __v_1, __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, __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_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[656].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_656] = unsafe { *(result.output.as_ptr() as *const [G; OUT_656]) }; __ret } else { aiur_fn_656(__args, record, io_buffer, __cu)? } };
+        let __v_51: G = G::from_u64(1);
+        let __v_52: G = (__v_3 + __v_51);
+        let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_0, __v_1, __v_50, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[655].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_655] = unsafe { *(result.output.as_ptr() as *const [G; OUT_655]) }; __ret } else { aiur_fn_655(__args, record, io_buffer, __cu)? } };
+        let __ret: [G; OUT_655] = [];
+        record.function_queries[655].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
+      },
     }
   })
 }
 
-const INPUT_SIZE_732: usize = 2;
-const IN_732: usize = 2;
-const OUT_732: usize = 3;
-fn aiur_fn_732(
-  inp: [G; IN_732],
+const INPUT_SIZE_656: usize = 48;
+const IN_656: usize = 48;
+const OUT_656: usize = 0;
+fn aiur_fn_656(
+  inp: [G; IN_656],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_732], ExecError> {
+) -> Result<[G; OUT_656], 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(1);
-        let __v_3: G = G::from_u64(1);
-        let __ret: [G; OUT_732] = [__v_2, __v_3, __v_1];
-        record.function_queries[732].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { 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_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_731] = { let __args: [G; IN_731] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[731].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_731] = unsafe { *(result.output.as_ptr() as *const [G; OUT_731]) }; __ret } else { aiur_fn_731(__args, record, io_buffer, __cu)? } };
-        let __v_11: G = __r_arr[0];
-        let __v_12: G = __r_arr[1];
-        let __v_13: G = G::from_u64(0);
-        let __ret: [G; OUT_732] = [__v_13, __v_11, __v_12];
-        record.function_queries[732].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-    }
+    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 __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_1, __v_0, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[266].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_266] = unsafe { *(result.output.as_ptr() as *const [G; OUT_266]) }; __ret } else { aiur_fn_266(__args, record, io_buffer, __cu)? } };
+    let __v_48: G = __r_arr[0];
+    let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[258].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_258] = unsafe { *(result.output.as_ptr() as *const [G; OUT_258]) }; __ret } else { aiur_fn_258(__args, record, io_buffer, __cu)? } };
+    let __v_49: G = __r_arr[0];
+    let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_49.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+    let __v_50: G = __loaded[0];
+    let __v_51: G = __loaded[1];
+    let __v_52: G = __loaded[2];
+    let __v_53: G = __loaded[3];
+    let __v_54: G = __loaded[4];
+    let __v_55: G = __loaded[5];
+    let __v_56: G = __loaded[6];
+    let __v_57: G = __loaded[7];
+    let __v_58: G = __loaded[8];
+    let __v_59: G = __loaded[9];
+    let __v_60: G = __loaded[10];
+    let __v_61: G = __loaded[11];
+    let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__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_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[644].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_644] = unsafe { *(result.output.as_ptr() as *const [G; OUT_644]) }; __ret } else { aiur_fn_644(__args, record, io_buffer, __cu)? } };
+    let __ret: [G; OUT_656] = [];
+    record.function_queries[656].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_657: usize = 1;
+const IN_657: usize = 1;
+const OUT_657: usize = 1;
+fn aiur_fn_657(
+  inp: [G; IN_657],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_657], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = G::from_u64(1);
+    let __v_2: G = G::from_u64(1);
+    let __v_3: G = { let __values: [G; 3] = [__v_1, __v_2, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_41] = { let __args: [G; IN_41] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[41].get_mut(&__args[..]) { 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_4: G = __r_arr[0];
+    let __v_5: G = G::from_u64(0);
+    let __v_6: G = G::from_u64(0);
+    let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __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 __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[18].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_18] = unsafe { *(result.output.as_ptr() as *const [G; OUT_18]) }; __ret } else { aiur_fn_18(__args, record, io_buffer, __cu)? } };
+    let __v_8: G = __r_arr[0];
+    let __ret: [G; OUT_657] = [__v_8];
+    record.function_queries[657].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_658: usize = 2;
+const IN_658: usize = 2;
+const OUT_658: usize = 1;
+fn aiur_fn_658(
+  inp: [G; IN_658],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_658], 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_41] = { let __args: [G; IN_41] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[41].get_mut(&__args[..]) { 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_5: G = __r_arr[0];
+    let __r_arr: [G; OUT_41] = { let __args: [G; IN_41] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[41].get_mut(&__args[..]) { 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 = G::from_u64(0);
+    let __v_8: G = G::from_u64(1);
+    let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __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 __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[18].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_18] = unsafe { *(result.output.as_ptr() as *const [G; OUT_18]) }; __ret } else { aiur_fn_18(__args, record, io_buffer, __cu)? } };
+    let __v_10: G = __r_arr[0];
+    let __ret: [G; OUT_658] = [__v_10];
+    record.function_queries[658].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_733: usize = 1;
-const IN_733: usize = 1;
-const OUT_733: usize = 55;
-fn aiur_fn_733(
-  inp: [G; IN_733],
+const INPUT_SIZE_659: usize = 1;
+const IN_659: usize = 1;
+const OUT_659: usize = 3;
+fn aiur_fn_659(
+  inp: [G; IN_659],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_733], ExecError> {
+) -> Result<[G; OUT_659], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[66].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { 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_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
-    let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { 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_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 __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_12: G = __b1_out[0];
-    let __v_13: G = __b1_out[1];
-    let __v_14: G = __b1_out[2];
-    let __v_15: G = __b1_out[3];
-    let __v_16: G = __b1_out[4];
-    let __v_17: G = __b1_out[5];
-    let __v_18: G = __b1_out[6];
-    let __v_19: 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_20: G = __b1_out[0];
-    let __v_21: G = __b1_out[1];
-    let __v_22: G = __b1_out[2];
-    let __v_23: G = __b1_out[3];
-    let __v_24: G = __b1_out[4];
-    let __v_25: G = __b1_out[5];
-    let __v_26: G = __b1_out[6];
-    let __v_27: G = __b1_out[7];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_725] = { let __args: [G; IN_725] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[725].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_725] = unsafe { *(result.output.as_ptr() as *const [G; OUT_725]) }; __ret } else { aiur_fn_725(__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 __r_arr: [G; OUT_725] = { let __args: [G; IN_725] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[725].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_725] = unsafe { *(result.output.as_ptr() as *const [G; OUT_725]) }; __ret } else { aiur_fn_725(__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 __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_14, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } };
-        let __v_34: G = __r_arr[0];
-        let __v_35: G = __r_arr[1];
-        let __v_36: G = __r_arr[2];
-        let __v_37: G = __r_arr[3];
-        let __v_38: G = __r_arr[4];
-        let __v_39: G = __r_arr[5];
-        let __v_40: G = __r_arr[6];
-        let __v_41: G = __r_arr[7];
-        let __v_42: G = __r_arr[8];
-        let __v_43: G = __r_arr[9];
-        let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_15, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[723].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_723] = unsafe { *(result.output.as_ptr() as *const [G; OUT_723]) }; __ret } else { aiur_fn_723(__args, record, io_buffer, __cu)? } };
-        let __v_44: G = __r_arr[0];
-        let __v_45: G = __r_arr[1];
-        let __v_46: G = __r_arr[2];
-        let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_16, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[723].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_723] = unsafe { *(result.output.as_ptr() as *const [G; OUT_723]) }; __ret } else { aiur_fn_723(__args, record, io_buffer, __cu)? } };
-        let __v_47: G = __r_arr[0];
-        let __v_48: G = __r_arr[1];
-        let __v_49: G = __r_arr[2];
-        let __v_50: G = G::from_u64(0);
-        let __v_51: G = G::from_u64(0);
-        let __ret: [G; OUT_733] = [__v_50, __v_28, __v_29, __v_31, __v_32, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_44, __v_45, __v_47, __v_48, __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, __v_51, __v_51, __v_51, __v_49];
-        record.function_queries[733].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[81].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_81] = unsafe { *(result.output.as_ptr() as *const [G; OUT_81]) }; __ret } else { aiur_fn_81(__args, record, io_buffer, __cu)? } };
+        let __v_3: G = __r_arr[0];
+        let __v_4: G = __r_arr[1];
+        let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[657].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_657] = unsafe { *(result.output.as_ptr() as *const [G; OUT_657]) }; __ret } else { aiur_fn_657(__args, record, io_buffer, __cu)? } };
+        let __v_5: G = __r_arr[0];
+        let __v_6: G = G::from_u64(0);
+        let __v_7: G = G::from_u64(1);
+        let __v_8: G = G::from_u64(1);
+        let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __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_10: G = { let __values: [G; 3] = [__v_6, __v_3, __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 __ret: [G; OUT_659] = [__v_5, __v_10, __v_4];
+        record.function_queries[659].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[724].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_724] = unsafe { *(result.output.as_ptr() as *const [G; OUT_724]) }; __ret } else { aiur_fn_724(__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 __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__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_722] = { let __args: [G; IN_722] = [__v_14, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__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_722] = { let __args: [G; IN_722] = [__v_15, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__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_723] = { let __args: [G; IN_723] = [__v_16, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[723].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_723] = unsafe { *(result.output.as_ptr() as *const [G; OUT_723]) }; __ret } else { aiur_fn_723(__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 __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__v_17, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[732].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_732] = unsafe { *(result.output.as_ptr() as *const [G; OUT_732]) }; __ret } else { aiur_fn_732(__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 = G::from_u64(1);
-        let __v_68: G = G::from_u64(0);
-        let __ret: [G; OUT_733] = [__v_67, __v_28, __v_29, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_61, __v_62, __v_64, __v_65, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_66];
-        record.function_queries[733].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __v_3: G = G::from_u64(0);
+        let __v_4: G = G::from_u64(0);
+        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 __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 = 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 __v_24: G = G::from_u64(0);
+        let __v_25: G = G::from_u64(0);
+        let __v_26: G = G::from_u64(0);
+        let __v_27: G = G::from_u64(0);
+        let __v_28: G = G::from_u64(0);
+        let __v_29: G = G::from_u64(0);
+        let __v_30: G = G::from_u64(0);
+        let __v_31: G = G::from_u64(0);
+        let __v_32: G = G::from_u64(0);
+        let __v_33: G = G::from_u64(0);
+        let __v_34: G = G::from_u64(0);
+        let __v_35: G = { let __values: [G; 32] = [__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]; 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_36: G = G::from_u64(1);
+        let __v_37: G = G::from_u64(1);
+        let __v_38: G = { let __values: [G; 3] = [__v_36, __v_37, __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 __ret: [G; OUT_659] = [__v_35, __v_38, __v_2];
+        record.function_queries[659].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[724].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_724] = unsafe { *(result.output.as_ptr() as *const [G; OUT_724]) }; __ret } else { aiur_fn_724(__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 __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[724].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_724] = unsafe { *(result.output.as_ptr() as *const [G; OUT_724]) }; __ret } else { aiur_fn_724(__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 __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_14, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } };
-        let __v_34: G = __r_arr[0];
-        let __v_35: G = __r_arr[1];
-        let __v_36: G = __r_arr[2];
-        let __v_37: G = __r_arr[3];
-        let __v_38: G = __r_arr[4];
-        let __v_39: G = __r_arr[5];
-        let __v_40: G = __r_arr[6];
-        let __v_41: G = __r_arr[7];
-        let __v_42: G = __r_arr[8];
-        let __v_43: G = __r_arr[9];
-        let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_15, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } };
-        let __v_44: G = __r_arr[0];
-        let __v_45: G = __r_arr[1];
-        let __v_46: G = __r_arr[2];
-        let __v_47: G = __r_arr[3];
-        let __v_48: G = __r_arr[4];
-        let __v_49: G = __r_arr[5];
-        let __v_50: G = __r_arr[6];
-        let __v_51: G = __r_arr[7];
-        let __v_52: G = __r_arr[8];
-        let __v_53: G = __r_arr[9];
-        let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_16, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__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 __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_17, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__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 __v_68: G = __r_arr[4];
-        let __v_69: G = __r_arr[5];
-        let __v_70: G = __r_arr[6];
-        let __v_71: G = __r_arr[7];
-        let __v_72: G = __r_arr[8];
-        let __v_73: G = __r_arr[9];
-        let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_18, __v_73]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } };
-        let __v_74: G = __r_arr[0];
-        let __v_75: G = __r_arr[1];
-        let __v_76: G = __r_arr[2];
-        let __v_77: G = __r_arr[3];
-        let __v_78: G = __r_arr[4];
-        let __v_79: G = __r_arr[5];
-        let __v_80: G = __r_arr[6];
-        let __v_81: G = __r_arr[7];
-        let __v_82: G = __r_arr[8];
-        let __v_83: G = __r_arr[9];
-        let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_19, __v_83]; let __cu = unconstrained; if let Some(result) = record.function_queries[723].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_723] = unsafe { *(result.output.as_ptr() as *const [G; OUT_723]) }; __ret } else { aiur_fn_723(__args, record, io_buffer, __cu)? } };
-        let __v_84: G = __r_arr[0];
-        let __v_85: G = __r_arr[1];
-        let __v_86: G = __r_arr[2];
-        let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_20, __v_86]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } };
-        let __v_87: G = __r_arr[0];
-        let __v_88: G = __r_arr[1];
-        let __v_89: G = __r_arr[2];
-        let __v_90: G = G::from_u64(2);
-        let __ret: [G; OUT_733] = [__v_90, __v_28, __v_29, __v_31, __v_32, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_84, __v_85, __v_87, __v_88, __v_89];
-        record.function_queries[733].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__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 __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__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 __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } };
+        let __v_9: G = __r_arr[0];
+        let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[710].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_710] = unsafe { *(result.output.as_ptr() as *const [G; OUT_710]) }; __ret } else { aiur_fn_710(__args, record, io_buffer, __cu)? } };
+        let __v_10: G = __r_arr[0];
+        let __ret: [G; OUT_659] = [__v_9, __v_10, __v_8];
+        record.function_queries[659].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -61045,98 +53949,293 @@ fn aiur_fn_733(
   })
 }
 
-const INPUT_SIZE_734: usize = 1;
-const IN_734: usize = 1;
-const OUT_734: usize = 63;
-fn aiur_fn_734(
-  inp: [G; IN_734],
+const INPUT_SIZE_660: usize = 1;
+const IN_660: usize = 1;
+const OUT_660: usize = 1;
+fn aiur_fn_660(
+  inp: [G; IN_660],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_734], ExecError> {
+) -> Result<[G; OUT_660], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { 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_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_733] = { let __args: [G; IN_733] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = unsafe { *(result.output.as_ptr() as *const [G; OUT_733]) }; __ret } else { aiur_fn_733(__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 = __r_arr[9];
-    let __v_20: G = __r_arr[10];
-    let __v_21: G = __r_arr[11];
-    let __v_22: G = __r_arr[12];
-    let __v_23: G = __r_arr[13];
-    let __v_24: G = __r_arr[14];
-    let __v_25: G = __r_arr[15];
-    let __v_26: G = __r_arr[16];
-    let __v_27: G = __r_arr[17];
-    let __v_28: G = __r_arr[18];
-    let __v_29: G = __r_arr[19];
-    let __v_30: G = __r_arr[20];
-    let __v_31: G = __r_arr[21];
-    let __v_32: G = __r_arr[22];
-    let __v_33: G = __r_arr[23];
-    let __v_34: G = __r_arr[24];
-    let __v_35: G = __r_arr[25];
-    let __v_36: G = __r_arr[26];
-    let __v_37: G = __r_arr[27];
-    let __v_38: G = __r_arr[28];
-    let __v_39: G = __r_arr[29];
-    let __v_40: G = __r_arr[30];
-    let __v_41: G = __r_arr[31];
-    let __v_42: G = __r_arr[32];
-    let __v_43: G = __r_arr[33];
-    let __v_44: G = __r_arr[34];
-    let __v_45: G = __r_arr[35];
-    let __v_46: G = __r_arr[36];
-    let __v_47: G = __r_arr[37];
-    let __v_48: G = __r_arr[38];
-    let __v_49: G = __r_arr[39];
-    let __v_50: G = __r_arr[40];
-    let __v_51: G = __r_arr[41];
-    let __v_52: G = __r_arr[42];
-    let __v_53: G = __r_arr[43];
-    let __v_54: G = __r_arr[44];
-    let __v_55: G = __r_arr[45];
-    let __v_56: G = __r_arr[46];
-    let __v_57: G = __r_arr[47];
-    let __v_58: G = __r_arr[48];
-    let __v_59: G = __r_arr[49];
-    let __v_60: G = __r_arr[50];
-    let __v_61: G = __r_arr[51];
-    let __v_62: G = __r_arr[52];
-    let __v_63: G = __r_arr[53];
-    let __v_64: G = __r_arr[54];
-    let __ret: [G; OUT_734] = [__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_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];
-    record.function_queries[734].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_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_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 = G::from_u64(1);
+    let __io_pair: (G, G) = { let __key: [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 __info = io_buffer.get_info(__v_33, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) };
+    let __v_34: G = __io_pair.0;
+    let __v_35: G = __io_pair.1;
+    let __v_36: G = G::from_u64(1);
+    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_36, __v_34, __v_35]; let __cu = true; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
+    let __v_37: G = __r_arr[0];
+    let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } else { aiur_fn_72(__args, record, io_buffer, __cu)? } };
+    let __v_38: G = __r_arr[0];
+    let __v_39: G = __r_arr[1];
+    let __v_40: G = __r_arr[2];
+    let __v_41: G = __r_arr[3];
+    let __v_42: G = __r_arr[4];
+    let __v_43: G = __r_arr[5];
+    let __v_44: G = __r_arr[6];
+    let __v_45: G = __r_arr[7];
+    let __v_46: G = __r_arr[8];
+    let __v_47: G = __r_arr[9];
+    let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__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];
+    let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; 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: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+    let __v_51: G = __loaded[0];
+    let __v_52: G = __loaded[1];
+    let __v_53: G = __loaded[2];
+    let __v_54: G = __loaded[3];
+    let __v_55: G = __loaded[4];
+    let __v_56: G = __loaded[5];
+    let __v_57: G = __loaded[6];
+    let __v_58: G = __loaded[7];
+    let __v_59: G = __loaded[8];
+    let __v_60: G = __loaded[9];
+    let __v_61: G = __loaded[10];
+    let __v_62: G = __loaded[11];
+    let __v_63: G = __loaded[12];
+    let __v_64: G = __loaded[13];
+    let __v_65: G = __loaded[14];
+    let __v_66: G = __loaded[15];
+    let __v_67: G = __loaded[16];
+    let __v_68: G = __loaded[17];
+    let __v_69: G = __loaded[18];
+    let __v_70: G = __loaded[19];
+    let __v_71: G = __loaded[20];
+    let __v_72: G = __loaded[21];
+    let __v_73: G = __loaded[22];
+    let __v_74: G = __loaded[23];
+    let __v_75: G = __loaded[24];
+    let __v_76: G = __loaded[25];
+    let __v_77: G = __loaded[26];
+    let __v_78: G = __loaded[27];
+    let __v_79: G = __loaded[28];
+    let __v_80: G = __loaded[29];
+    let __v_81: G = __loaded[30];
+    let __v_82: G = __loaded[31];
+    let __v_83: G = G::from_u64(14);
+    if (__v_38 != __v_83) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_38.as_canonical_u64(), rhs: __v_83.as_canonical_u64(), msg: Some("assumption tree: wrong tag4 flag".to_string()) });
+    }
+    let __v_84: G = G::from_u64(2);
+    if (__v_39 != __v_84) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_39.as_canonical_u64(), rhs: __v_84.as_canonical_u64(), msg: Some("assumption tree: wrong tag4 variant".to_string()) });
+    }
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_50.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).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];
+    let __v_88: G = G::from_u64(1);
+    let __v_89: G = G::from_u64(1);
+    if (__v_85 != __v_88) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_85.as_canonical_u64(), rhs: __v_88.as_canonical_u64(), msg: Some("assumption tree: trailing bytes after tree body".to_string()) });
+    }
+    if (__v_86 != __v_89) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_86.as_canonical_u64(), rhs: __v_89.as_canonical_u64(), msg: Some("assumption tree: trailing bytes after tree body".to_string()) });
+    }
+    if (__v_87 != __v_89) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_87.as_canonical_u64(), rhs: __v_89.as_canonical_u64(), msg: Some("assumption tree: trailing bytes after tree body".to_string()) });
+    }
+    if (__v_51 != __v_1) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_51.as_canonical_u64(), rhs: __v_1.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) });
+    }
+    if (__v_52 != __v_2) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_52.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) });
+    }
+    if (__v_53 != __v_3) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_53.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) });
+    }
+    if (__v_54 != __v_4) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_54.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) });
+    }
+    if (__v_55 != __v_5) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_55.as_canonical_u64(), rhs: __v_5.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) });
+    }
+    if (__v_56 != __v_6) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_56.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) });
+    }
+    if (__v_57 != __v_7) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_57.as_canonical_u64(), rhs: __v_7.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) });
+    }
+    if (__v_58 != __v_8) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_58.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) });
+    }
+    if (__v_59 != __v_9) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_59.as_canonical_u64(), rhs: __v_9.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) });
+    }
+    if (__v_60 != __v_10) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_60.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) });
+    }
+    if (__v_61 != __v_11) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_61.as_canonical_u64(), rhs: __v_11.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) });
+    }
+    if (__v_62 != __v_12) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_62.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) });
+    }
+    if (__v_63 != __v_13) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_63.as_canonical_u64(), rhs: __v_13.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) });
+    }
+    if (__v_64 != __v_14) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_64.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) });
+    }
+    if (__v_65 != __v_15) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_65.as_canonical_u64(), rhs: __v_15.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) });
+    }
+    if (__v_66 != __v_16) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_66.as_canonical_u64(), rhs: __v_16.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) });
+    }
+    if (__v_67 != __v_17) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_67.as_canonical_u64(), rhs: __v_17.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) });
+    }
+    if (__v_68 != __v_18) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_68.as_canonical_u64(), rhs: __v_18.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) });
+    }
+    if (__v_69 != __v_19) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_69.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) });
+    }
+    if (__v_70 != __v_20) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_70.as_canonical_u64(), rhs: __v_20.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) });
+    }
+    if (__v_71 != __v_21) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_71.as_canonical_u64(), rhs: __v_21.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) });
+    }
+    if (__v_72 != __v_22) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_72.as_canonical_u64(), rhs: __v_22.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) });
+    }
+    if (__v_73 != __v_23) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_73.as_canonical_u64(), rhs: __v_23.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) });
+    }
+    if (__v_74 != __v_24) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_74.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) });
+    }
+    if (__v_75 != __v_25) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_75.as_canonical_u64(), rhs: __v_25.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) });
+    }
+    if (__v_76 != __v_26) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_76.as_canonical_u64(), rhs: __v_26.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) });
+    }
+    if (__v_77 != __v_27) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_77.as_canonical_u64(), rhs: __v_27.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) });
+    }
+    if (__v_78 != __v_28) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_78.as_canonical_u64(), rhs: __v_28.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) });
+    }
+    if (__v_79 != __v_29) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_79.as_canonical_u64(), rhs: __v_29.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) });
+    }
+    if (__v_80 != __v_30) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_80.as_canonical_u64(), rhs: __v_30.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) });
+    }
+    if (__v_81 != __v_31) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_81.as_canonical_u64(), rhs: __v_31.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) });
+    }
+    if (__v_82 != __v_32) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_82.as_canonical_u64(), rhs: __v_32.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) });
+    }
+    let __ret: [G; OUT_660] = [__v_49];
+    record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_735: usize = 9;
-const IN_735: usize = 9;
-const OUT_735: usize = 2;
-fn aiur_fn_735(
-  inp: [G; IN_735],
+const INPUT_SIZE_661: usize = 7;
+const IN_661: usize = 7;
+const OUT_661: usize = 6;
+fn aiur_fn_661(
+  inp: [G; IN_661],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_661], 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 __ret: [G; OUT_661] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6];
+        record.function_queries[661].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __v_10: G = G::from_u64(1);
+        let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_8, __v_10, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[724].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_724] = unsafe { *(result.output.as_ptr() as *const [G; OUT_724]) }; __ret } else { aiur_fn_724(__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 __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_9, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[661].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_661] = unsafe { *(result.output.as_ptr() as *const [G; OUT_661]) }; __ret } else { aiur_fn_661(__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 __ret: [G; OUT_661] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22];
+        record.function_queries[661].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_662: usize = 7;
+const IN_662: usize = 7;
+const OUT_662: usize = 1;
+fn aiur_fn_662(
+  inp: [G; IN_662],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_735], ExecError> {
+) -> Result<[G; OUT_662], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -61145,621 +54244,248 @@ fn aiur_fn_735(
     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_2] = { let __args: [G; IN_2] = [__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[2].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
-    let __v_9: G = __r_arr[0];
-    match __v_9.as_canonical_u64() {
-      1u64 => {
-        let __v_10: G = G::from_u64(1);
-        let __v_11: G = G::from_u64(1);
-        let __v_12: G = { let __values: [G; 64] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&64).ok_or(ExecError::InvalidMemorySize(64))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_735] = [__v_12, __v_0];
-        record.function_queries[735].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[734].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_734] = unsafe { *(result.output.as_ptr() as *const [G; OUT_734]) }; __ret } else { aiur_fn_734(__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 = __r_arr[9];
-        let __v_20: G = __r_arr[10];
-        let __v_21: G = __r_arr[11];
-        let __v_22: G = __r_arr[12];
-        let __v_23: G = __r_arr[13];
-        let __v_24: G = __r_arr[14];
-        let __v_25: G = __r_arr[15];
-        let __v_26: G = __r_arr[16];
-        let __v_27: G = __r_arr[17];
-        let __v_28: G = __r_arr[18];
-        let __v_29: G = __r_arr[19];
-        let __v_30: G = __r_arr[20];
-        let __v_31: G = __r_arr[21];
-        let __v_32: G = __r_arr[22];
-        let __v_33: G = __r_arr[23];
-        let __v_34: G = __r_arr[24];
-        let __v_35: G = __r_arr[25];
-        let __v_36: G = __r_arr[26];
-        let __v_37: G = __r_arr[27];
-        let __v_38: G = __r_arr[28];
-        let __v_39: G = __r_arr[29];
-        let __v_40: G = __r_arr[30];
-        let __v_41: G = __r_arr[31];
-        let __v_42: G = __r_arr[32];
-        let __v_43: G = __r_arr[33];
-        let __v_44: G = __r_arr[34];
-        let __v_45: G = __r_arr[35];
-        let __v_46: G = __r_arr[36];
-        let __v_47: G = __r_arr[37];
-        let __v_48: G = __r_arr[38];
-        let __v_49: G = __r_arr[39];
-        let __v_50: G = __r_arr[40];
-        let __v_51: G = __r_arr[41];
-        let __v_52: G = __r_arr[42];
-        let __v_53: G = __r_arr[43];
-        let __v_54: G = __r_arr[44];
-        let __v_55: G = __r_arr[45];
-        let __v_56: G = __r_arr[46];
-        let __v_57: G = __r_arr[47];
-        let __v_58: G = __r_arr[48];
-        let __v_59: G = __r_arr[49];
-        let __v_60: G = __r_arr[50];
-        let __v_61: G = __r_arr[51];
-        let __v_62: G = __r_arr[52];
-        let __v_63: G = __r_arr[53];
-        let __v_64: G = __r_arr[54];
-        let __v_65: G = __r_arr[55];
-        let __v_66: G = __r_arr[56];
-        let __v_67: G = __r_arr[57];
-        let __v_68: G = __r_arr[58];
-        let __v_69: G = __r_arr[59];
-        let __v_70: G = __r_arr[60];
-        let __v_71: G = __r_arr[61];
-        let __v_72: G = __r_arr[62];
-        let __r_arr: [G; OUT_12] = { let __args: [G; IN_12] = [__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[12].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_12] = unsafe { *(result.output.as_ptr() as *const [G; OUT_12]) }; __ret } else { aiur_fn_12(__args, record, io_buffer, __cu)? } };
-        let __v_73: G = __r_arr[0];
-        let __v_74: G = __r_arr[1];
-        let __v_75: G = __r_arr[2];
-        let __v_76: G = __r_arr[3];
-        let __v_77: G = __r_arr[4];
-        let __v_78: G = __r_arr[5];
-        let __v_79: G = __r_arr[6];
-        let __v_80: G = __r_arr[7];
-        let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80]; let __cu = unconstrained; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = unsafe { *(result.output.as_ptr() as *const [G; OUT_735]) }; __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } };
-        let __v_81: G = __r_arr[0];
-        let __v_82: G = __r_arr[1];
-        let __v_83: G = G::from_u64(0);
-        let __v_84: G = { let __values: [G; 64] = [__v_83, __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_81]; let __mq = record.memory_queries.get_mut(&64).ok_or(ExecError::InvalidMemorySize(64))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_735] = [__v_84, __v_82];
-        record.function_queries[735].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-    }
+    let __v_7: G = G::from_u64(0);
+    let __r_arr: [G; OUT_708] = { let __args: [G; IN_708] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[708].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_708] = unsafe { *(result.output.as_ptr() as *const [G; OUT_708]) }; __ret } else { aiur_fn_708(__args, record, io_buffer, __cu)? } };
+    let __v_8: G = __r_arr[0];
+    let __ret: [G; OUT_662] = [__v_8];
+    record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_736: usize = 1;
-const IN_736: usize = 1;
-const OUT_736: usize = 55;
-fn aiur_fn_736(
-  inp: [G; IN_736],
+const INPUT_SIZE_663: usize = 14;
+const IN_663: usize = 14;
+const OUT_663: usize = 0;
+fn aiur_fn_663(
+  inp: [G; IN_663],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_736], ExecError> {
+) -> Result<[G; OUT_663], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[66].get_mut(&__args[..]) { 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_1: G = __r_arr[0];
-    let __v_2: G = __r_arr[1];
-    let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { 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_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 __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_12: G = __b1_out[0];
-    let __v_13: G = __b1_out[1];
-    let __v_14: G = __b1_out[2];
-    let __v_15: G = __b1_out[3];
-    let __v_16: G = __b1_out[4];
-    let __v_17: G = __b1_out[5];
-    let __v_18: G = __b1_out[6];
-    let __v_19: 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_20: G = __b1_out[0];
-    let __v_21: G = __b1_out[1];
-    let __v_22: G = __b1_out[2];
-    let __v_23: G = __b1_out[3];
-    let __v_24: G = __b1_out[4];
-    let __v_25: G = __b1_out[5];
-    let __v_26: G = __b1_out[6];
-    let __v_27: G = __b1_out[7];
-    match __v_1.as_canonical_u64() {
-      0u64 => {
-        let __r_arr: [G; OUT_725] = { let __args: [G; IN_725] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[725].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_725] = unsafe { *(result.output.as_ptr() as *const [G; OUT_725]) }; __ret } else { aiur_fn_725(__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 __r_arr: [G; OUT_725] = { let __args: [G; IN_725] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[725].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_725] = unsafe { *(result.output.as_ptr() as *const [G; OUT_725]) }; __ret } else { aiur_fn_725(__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 __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_14, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } };
-        let __v_34: G = __r_arr[0];
-        let __v_35: G = __r_arr[1];
-        let __v_36: G = __r_arr[2];
-        let __v_37: G = __r_arr[3];
-        let __v_38: G = __r_arr[4];
-        let __v_39: G = __r_arr[5];
-        let __v_40: G = __r_arr[6];
-        let __v_41: G = __r_arr[7];
-        let __v_42: G = __r_arr[8];
-        let __v_43: G = __r_arr[9];
-        let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_15, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[723].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_723] = unsafe { *(result.output.as_ptr() as *const [G; OUT_723]) }; __ret } else { aiur_fn_723(__args, record, io_buffer, __cu)? } };
-        let __v_44: G = __r_arr[0];
-        let __v_45: G = __r_arr[1];
-        let __v_46: G = __r_arr[2];
-        let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_16, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[723].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_723] = unsafe { *(result.output.as_ptr() as *const [G; OUT_723]) }; __ret } else { aiur_fn_723(__args, record, io_buffer, __cu)? } };
-        let __v_47: G = __r_arr[0];
-        let __v_48: G = __r_arr[1];
-        let __v_49: G = __r_arr[2];
-        let __v_50: G = G::from_u64(0);
-        let __v_51: G = G::from_u64(0);
-        let __ret: [G; OUT_736] = [__v_50, __v_28, __v_29, __v_31, __v_32, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_44, __v_45, __v_47, __v_48, __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, __v_51, __v_51, __v_51, __v_49];
-        record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
+    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 __r_arr: [G; OUT_662] = { let __args: [G; IN_662] = [__v_0, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[662].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_662] = unsafe { *(result.output.as_ptr() as *const [G; OUT_662]) }; __ret } else { aiur_fn_662(__args, record, io_buffer, __cu)? } };
+    let __v_14: G = __r_arr[0];
+    match __v_14.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[724].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_724] = unsafe { *(result.output.as_ptr() as *const [G; OUT_724]) }; __ret } else { aiur_fn_724(__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 __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[724].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_724] = unsafe { *(result.output.as_ptr() as *const [G; OUT_724]) }; __ret } else { aiur_fn_724(__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 __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_14, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } };
-        let __v_34: G = __r_arr[0];
-        let __v_35: G = __r_arr[1];
-        let __v_36: G = __r_arr[2];
-        let __v_37: G = __r_arr[3];
-        let __v_38: G = __r_arr[4];
-        let __v_39: G = __r_arr[5];
-        let __v_40: G = __r_arr[6];
-        let __v_41: G = __r_arr[7];
-        let __v_42: G = __r_arr[8];
-        let __v_43: G = __r_arr[9];
-        let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_15, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } };
-        let __v_44: G = __r_arr[0];
-        let __v_45: G = __r_arr[1];
-        let __v_46: G = __r_arr[2];
-        let __v_47: G = __r_arr[3];
-        let __v_48: G = __r_arr[4];
-        let __v_49: G = __r_arr[5];
-        let __v_50: G = __r_arr[6];
-        let __v_51: G = __r_arr[7];
-        let __v_52: G = __r_arr[8];
-        let __v_53: G = __r_arr[9];
-        let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_16, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__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 __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_17, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__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 __v_68: G = __r_arr[4];
-        let __v_69: G = __r_arr[5];
-        let __v_70: G = __r_arr[6];
-        let __v_71: G = __r_arr[7];
-        let __v_72: G = __r_arr[8];
-        let __v_73: G = __r_arr[9];
-        let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_18, __v_73]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } };
-        let __v_74: G = __r_arr[0];
-        let __v_75: G = __r_arr[1];
-        let __v_76: G = __r_arr[2];
-        let __v_77: G = __r_arr[3];
-        let __v_78: G = __r_arr[4];
-        let __v_79: G = __r_arr[5];
-        let __v_80: G = __r_arr[6];
-        let __v_81: G = __r_arr[7];
-        let __v_82: G = __r_arr[8];
-        let __v_83: G = __r_arr[9];
-        let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_19, __v_83]; let __cu = unconstrained; if let Some(result) = record.function_queries[723].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_723] = unsafe { *(result.output.as_ptr() as *const [G; OUT_723]) }; __ret } else { aiur_fn_723(__args, record, io_buffer, __cu)? } };
-        let __v_84: G = __r_arr[0];
-        let __v_85: G = __r_arr[1];
-        let __v_86: G = __r_arr[2];
-        let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_20, __v_86]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } };
-        let __v_87: G = __r_arr[0];
-        let __v_88: G = __r_arr[1];
-        let __v_89: G = __r_arr[2];
-        let __v_90: G = G::from_u64(1);
-        let __ret: [G; OUT_736] = [__v_90, __v_28, __v_29, __v_31, __v_32, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_84, __v_85, __v_87, __v_88, __v_89];
-        record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      2u64 => {
-        let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[724].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_724] = unsafe { *(result.output.as_ptr() as *const [G; OUT_724]) }; __ret } else { aiur_fn_724(__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 __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__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_723] = { let __args: [G; IN_723] = [__v_14, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[723].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_723] = unsafe { *(result.output.as_ptr() as *const [G; OUT_723]) }; __ret } else { aiur_fn_723(__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 = G::from_u64(2);
-        let __v_45: G = G::from_u64(0);
-        let __ret: [G; OUT_736] = [__v_44, __v_28, __v_29, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_41, __v_42, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_43];
-        record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      3u64 => {
-        let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[726].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_726] = unsafe { *(result.output.as_ptr() as *const [G; OUT_726]) }; __ret } else { aiur_fn_726(__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 __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__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_723] = { let __args: [G; IN_723] = [__v_14, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[723].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_723] = unsafe { *(result.output.as_ptr() as *const [G; OUT_723]) }; __ret } else { aiur_fn_723(__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 = G::from_u64(3);
-        let __v_45: G = G::from_u64(0);
-        let __ret: [G; OUT_736] = [__v_44, __v_28, __v_29, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_41, __v_42, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_43];
-        record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      4u64 => {
-        let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__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 __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_13, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } };
-        let __v_38: G = __r_arr[0];
-        let __v_39: G = __r_arr[1];
-        let __v_40: G = __r_arr[2];
-        let __v_41: G = __r_arr[3];
-        let __v_42: G = __r_arr[4];
-        let __v_43: G = __r_arr[5];
-        let __v_44: G = __r_arr[6];
-        let __v_45: G = __r_arr[7];
-        let __v_46: G = __r_arr[8];
-        let __v_47: G = __r_arr[9];
-        let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_14, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[723].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_723] = unsafe { *(result.output.as_ptr() as *const [G; OUT_723]) }; __ret } else { aiur_fn_723(__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];
-        let __v_51: G = G::from_u64(4);
-        let __v_52: G = G::from_u64(0);
-        let __ret: [G; OUT_736] = [__v_51, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_48, __v_49, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_50];
-        record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_663] = [];
+        record.function_queries[663].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      5u64 => {
-        let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__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 __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_13, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[723].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_723] = unsafe { *(result.output.as_ptr() as *const [G; OUT_723]) }; __ret } else { aiur_fn_723(__args, record, io_buffer, __cu)? } };
-        let __v_38: G = __r_arr[0];
-        let __v_39: G = __r_arr[1];
-        let __v_40: G = __r_arr[2];
-        let __v_41: G = G::from_u64(5);
-        let __v_42: G = G::from_u64(0);
-        let __ret: [G; OUT_736] = [__v_41, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_39, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_40];
-        record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
+      _ => {
+        let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_13.as_canonical_u64() {
+  1u64 => {
+    let __r_arr: [G; OUT_662] = { let __args: [G; IN_662] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[662].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_662] = unsafe { *(result.output.as_ptr() as *const [G; OUT_662]) }; __ret } else { aiur_fn_662(__args, record, io_buffer, __cu)? } };
+    let __v_15: G = __r_arr[0];
+    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: Some("CheckEnv: walk reached a constant outside the owned set".to_string()) });
+    }
+    break '__mc_0 [];
+  },
+  _ => {
+    break '__mc_0 [];
+  },
+}
+ };
+        let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } else { aiur_fn_255(__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 __v_26: G = __r_arr[11];
+        let __v_27: G = __r_arr[12];
+        let __v_28: G = __r_arr[13];
+        let __v_29: G = __r_arr[14];
+        let __v_30: G = __r_arr[15];
+        let __v_31: G = __r_arr[16];
+        let __v_32: G = __r_arr[17];
+        let __v_33: G = __r_arr[18];
+        let __v_34: G = __r_arr[19];
+        let __v_35: G = __r_arr[20];
+        let __v_36: G = __r_arr[21];
+        let __v_37: G = __r_arr[22];
+        let __v_38: G = __r_arr[23];
+        let __v_39: G = __r_arr[24];
+        let __v_40: G = __r_arr[25];
+        let __v_41: G = __r_arr[26];
+        let __v_42: G = __r_arr[27];
+        let __v_43: G = __r_arr[28];
+        let __v_44: G = __r_arr[29];
+        let __v_45: G = __r_arr[30];
+        let __v_46: G = __r_arr[31];
+        let __v_47: G = __r_arr[32];
+        let __v_48: G = __r_arr[33];
+        let __v_49: G = __r_arr[34];
+        let __v_50: G = __r_arr[35];
+        let __v_51: G = __r_arr[36];
+        let __v_52: G = __r_arr[37];
+        let __v_53: G = __r_arr[38];
+        let __v_54: G = __r_arr[39];
+        let __v_55: G = __r_arr[40];
+        let __v_56: G = __r_arr[41];
+        let __v_57: G = __r_arr[42];
+        let __v_58: G = __r_arr[43];
+        let __v_59: G = __r_arr[44];
+        let __v_60: G = __r_arr[45];
+        let __v_61: G = __r_arr[46];
+        let __v_62: G = __r_arr[47];
+        match __v_15.as_canonical_u64() {
+          _ => {
+            let __mc_out___mc_1: [G; 0] = '__mc_1: { match __v_15.as_canonical_u64() {
+  8u64 => {
+    let __v_63: G = G::from_u64(0);
+    let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_0, __v_16, __v_16, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[655].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_655] = unsafe { *(result.output.as_ptr() as *const [G; OUT_655]) }; __ret } else { aiur_fn_655(__args, record, io_buffer, __cu)? } };
+    break '__mc_1 [];
+  },
+  7u64 => {
+    match __v_16.as_canonical_u64() {
+      _ => {
+        let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = unsafe { *(result.output.as_ptr() as *const [G; OUT_645]) }; __ret } else { aiur_fn_645(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_24, __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]; let __cu = unconstrained; if let Some(result) = record.function_queries[663].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_663] = unsafe { *(result.output.as_ptr() as *const [G; OUT_663]) }; __ret } else { aiur_fn_663(__args, record, io_buffer, __cu)? } };
+        break '__mc_1 [];
       },
-      6u64 => {
-        let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__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 __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_13, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[723].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_723] = unsafe { *(result.output.as_ptr() as *const [G; OUT_723]) }; __ret } else { aiur_fn_723(__args, record, io_buffer, __cu)? } };
-        let __v_38: G = __r_arr[0];
-        let __v_39: G = __r_arr[1];
-        let __v_40: G = __r_arr[2];
-        let __v_41: G = G::from_u64(6);
-        let __v_42: G = G::from_u64(0);
-        let __ret: [G; OUT_736] = [__v_41, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_39, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_40];
-        record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
+    }
+  },
+  6u64 => {
+    match __v_16.as_canonical_u64() {
+      _ => {
+        let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = unsafe { *(result.output.as_ptr() as *const [G; OUT_645]) }; __ret } else { aiur_fn_645(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_24, __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]; let __cu = unconstrained; if let Some(result) = record.function_queries[663].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_663] = unsafe { *(result.output.as_ptr() as *const [G; OUT_663]) }; __ret } else { aiur_fn_663(__args, record, io_buffer, __cu)? } };
+        break '__mc_1 [];
       },
-      7u64 => {
-        let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__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 __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_13, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[723].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_723] = unsafe { *(result.output.as_ptr() as *const [G; OUT_723]) }; __ret } else { aiur_fn_723(__args, record, io_buffer, __cu)? } };
-        let __v_38: G = __r_arr[0];
-        let __v_39: G = __r_arr[1];
-        let __v_40: G = __r_arr[2];
-        let __v_41: G = G::from_u64(7);
-        let __v_42: G = G::from_u64(0);
-        let __ret: [G; OUT_736] = [__v_41, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_39, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_40];
-        record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
+    }
+  },
+  4u64 => {
+    match __v_16.as_canonical_u64() {
+      _ => {
+        let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = unsafe { *(result.output.as_ptr() as *const [G; OUT_645]) }; __ret } else { aiur_fn_645(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_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]; let __cu = unconstrained; if let Some(result) = record.function_queries[663].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_663] = unsafe { *(result.output.as_ptr() as *const [G; OUT_663]) }; __ret } else { aiur_fn_663(__args, record, io_buffer, __cu)? } };
+        break '__mc_1 [];
       },
-      8u64 => {
-        let __mc_out___mc_0: [G; 2] = '__mc_0: { match __v_12.as_canonical_u64() {
-  0u64 => {
-    let __v_28: G = G::from_u64(1);
-    let __v_29: G = G::from_u64(1);
-    let __v_30: G = { let __values: [G; 64] = [__v_28, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29]; let __mq = record.memory_queries.get_mut(&64).ok_or(ExecError::InvalidMemorySize(64))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    break '__mc_0 [__v_30, __v_11];
+    }
   },
-  1u64 => {
-    let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { 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_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 __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_36, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = unsafe { *(result.output.as_ptr() as *const [G; OUT_735]) }; __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } };
-    let __v_37: G = __r_arr[0];
-    let __v_38: G = __r_arr[1];
-    break '__mc_0 [__v_37, __v_38];
+  5u64 => {
+    match __v_16.as_canonical_u64() {
+      _ => {
+        let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = unsafe { *(result.output.as_ptr() as *const [G; OUT_645]) }; __ret } else { aiur_fn_645(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_24, __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]; let __cu = unconstrained; if let Some(result) = record.function_queries[663].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_663] = unsafe { *(result.output.as_ptr() as *const [G; OUT_663]) }; __ret } else { aiur_fn_663(__args, record, io_buffer, __cu)? } };
+        break '__mc_1 [];
+      },
+    }
   },
   _ => {
-    return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64()));
+    let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = unsafe { *(result.output.as_ptr() as *const [G; OUT_645]) }; __ret } else { aiur_fn_645(__args, record, io_buffer, __cu)? } };
+    break '__mc_1 [];
   },
 }
  };
-        let __v_28: G = __mc_out___mc_0[0];
-        let __v_29: G = __mc_out___mc_0[1];
-        let __v_30: G = G::from_u64(8);
-        let __v_31: G = G::from_u64(0);
-        let __ret: [G; OUT_736] = [__v_30, __v_28, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_29];
-        record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+            let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = [__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]; let __cu = unconstrained; if let Some(result) = record.function_queries[651].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_651] = unsafe { *(result.output.as_ptr() as *const [G; OUT_651]) }; __ret } else { aiur_fn_651(__args, record, io_buffer, __cu)? } };
+            let __v_63: G = __r_arr[0];
+            let __v_64: G = G::from_u64(0);
+            let __r_arr: [G; OUT_664] = { let __args: [G; IN_664] = [__v_61, __v_63, __v_64, __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]; let __cu = unconstrained; if let Some(result) = record.function_queries[664].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_664] = unsafe { *(result.output.as_ptr() as *const [G; OUT_664]) }; __ret } else { aiur_fn_664(__args, record, io_buffer, __cu)? } };
+            let __ret: [G; OUT_663] = [];
+            record.function_queries[663].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+        }
       },
     }
   })
 }
 
-const INPUT_SIZE_737: usize = 1;
-const IN_737: usize = 1;
-const OUT_737: usize = 57;
-fn aiur_fn_737(
-  inp: [G; IN_737],
+const INPUT_SIZE_664: usize = 16;
+const IN_664: usize = 16;
+const OUT_664: usize = 0;
+fn aiur_fn_664(
+  inp: [G; IN_664],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_737], ExecError> {
+) -> Result<[G; OUT_664], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[70].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_70] = unsafe { *(result.output.as_ptr() as *const [G; OUT_70]) }; __ret } else { aiur_fn_70(__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 __v_11: G = G::from_u64(14);
-    if (__v_1 != __v_11) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_1.as_canonical_u64(), rhs: __v_11.as_canonical_u64() });
-    }
-    match __v_2.as_canonical_u64() {
-      3u64 => {
-        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 !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 __v_13: G = __r_arr[1];
-        let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[79].get_mut(&__args[..]) { 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_14: G = __r_arr[0];
-        let __v_15: G = __r_arr[1];
-        let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } else { aiur_fn_721(__args, record, io_buffer, __cu)? } };
-        let __v_16: G = __r_arr[0];
-        let __v_17: G = __r_arr[1];
-        let __v_18: G = __r_arr[2];
-        let __v_19: G = G::from_u64(0);
-        let __v_20: G = G::from_u64(0);
-        let __ret: [G; OUT_737] = [__v_19, __v_12, __v_14, __v_16, __v_17, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_18];
-        record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      4u64 => {
-        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 !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 __v_13: G = __r_arr[1];
-        let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } else { aiur_fn_721(__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 __v_17: G = G::from_u64(1);
-        let __v_18: G = G::from_u64(0);
-        let __ret: [G; OUT_737] = [__v_17, __v_12, __v_14, __v_15, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_16];
-        record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      5u64 => {
-        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 !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 __v_13: G = __r_arr[1];
-        let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } else { aiur_fn_721(__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 __v_17: G = G::from_u64(2);
-        let __v_18: G = G::from_u64(0);
-        let __ret: [G; OUT_737] = [__v_17, __v_12, __v_14, __v_15, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_16];
-        record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      6u64 => {
-        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 !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 __v_13: G = __r_arr[1];
-        let __r_arr: [G; OUT_736] = { let __args: [G; IN_736] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[736].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_736] = unsafe { *(result.output.as_ptr() as *const [G; OUT_736]) }; __ret } else { aiur_fn_736(__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 __v_17: G = __r_arr[3];
-        let __v_18: G = __r_arr[4];
-        let __v_19: G = __r_arr[5];
-        let __v_20: G = __r_arr[6];
-        let __v_21: G = __r_arr[7];
-        let __v_22: G = __r_arr[8];
-        let __v_23: G = __r_arr[9];
-        let __v_24: G = __r_arr[10];
-        let __v_25: G = __r_arr[11];
-        let __v_26: G = __r_arr[12];
-        let __v_27: G = __r_arr[13];
-        let __v_28: G = __r_arr[14];
-        let __v_29: G = __r_arr[15];
-        let __v_30: G = __r_arr[16];
-        let __v_31: G = __r_arr[17];
-        let __v_32: G = __r_arr[18];
-        let __v_33: G = __r_arr[19];
-        let __v_34: G = __r_arr[20];
-        let __v_35: G = __r_arr[21];
-        let __v_36: G = __r_arr[22];
-        let __v_37: G = __r_arr[23];
-        let __v_38: G = __r_arr[24];
-        let __v_39: G = __r_arr[25];
-        let __v_40: G = __r_arr[26];
-        let __v_41: G = __r_arr[27];
-        let __v_42: G = __r_arr[28];
-        let __v_43: G = __r_arr[29];
-        let __v_44: G = __r_arr[30];
-        let __v_45: G = __r_arr[31];
-        let __v_46: G = __r_arr[32];
-        let __v_47: G = __r_arr[33];
-        let __v_48: G = __r_arr[34];
-        let __v_49: G = __r_arr[35];
-        let __v_50: G = __r_arr[36];
-        let __v_51: G = __r_arr[37];
-        let __v_52: G = __r_arr[38];
-        let __v_53: G = __r_arr[39];
-        let __v_54: G = __r_arr[40];
-        let __v_55: G = __r_arr[41];
-        let __v_56: G = __r_arr[42];
-        let __v_57: G = __r_arr[43];
-        let __v_58: G = __r_arr[44];
-        let __v_59: G = __r_arr[45];
-        let __v_60: G = __r_arr[46];
-        let __v_61: G = __r_arr[47];
-        let __v_62: G = __r_arr[48];
-        let __v_63: G = __r_arr[49];
-        let __v_64: G = __r_arr[50];
-        let __v_65: G = __r_arr[51];
-        let __v_66: G = __r_arr[52];
-        let __v_67: G = __r_arr[53];
-        let __v_68: G = __r_arr[54];
-        let __v_69: G = G::from_u64(3);
-        let __ret: [G; OUT_737] = [__v_69, __v_12, __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];
-        record.function_queries[737].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 = 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 __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_16: G = __loaded[0];
+    let __v_17: G = __loaded[1];
+    let __v_18: G = __loaded[2];
+    match __v_16.as_canonical_u64() {
+      1u64 => {
+        let __ret: [G; OUT_664] = [];
+        record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      7u64 => {
-        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 !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 __v_13: G = __r_arr[1];
-        let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[79].get_mut(&__args[..]) { 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_14: G = __r_arr[0];
-        let __v_15: G = __r_arr[1];
-        let __v_16: G = G::from_u64(4);
-        let __v_17: G = G::from_u64(0);
-        let __ret: [G; OUT_737] = [__v_16, __v_12, __v_14, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_15];
-        record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+      0u64 => {
+        let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = unsafe { *(result.output.as_ptr() as *const [G; OUT_652]) }; __ret } else { aiur_fn_652(__args, record, io_buffer, __cu)? } };
+        let __v_19: G = __r_arr[0];
+        let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_19.as_canonical_u64() {
+  1u64 => {
+    let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_17, __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]; let __cu = unconstrained; if let Some(result) = record.function_queries[663].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_663] = unsafe { *(result.output.as_ptr() as *const [G; OUT_663]) }; __ret } else { aiur_fn_663(__args, record, io_buffer, __cu)? } };
+    break '__mc_0 [];
+  },
+  _ => {
+    break '__mc_0 [];
+  },
+}
+ };
+        let __v_20: G = G::from_u64(1);
+        let __v_21: G = (__v_2 + __v_20);
+        let __r_arr: [G; OUT_664] = { let __args: [G; IN_664] = [__v_18, __v_1, __v_21, __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]; let __cu = unconstrained; if let Some(result) = record.function_queries[664].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_664] = unsafe { *(result.output.as_ptr() as *const [G; OUT_664]) }; __ret } else { aiur_fn_664(__args, record, io_buffer, __cu)? } };
+        let __ret: [G; OUT_664] = [];
+        record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+        return Err(ExecError::MatchNoCase(__v_16.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_738: usize = 32;
-const IN_738: usize = 32;
-const OUT_738: usize = 56;
-fn aiur_fn_738(
-  inp: [G; IN_738],
+const INPUT_SIZE_665: usize = 13;
+const IN_665: usize = 13;
+const OUT_665: usize = 0;
+fn aiur_fn_665(
+  inp: [G; IN_665],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_738], ExecError> {
+) -> Result<[G; OUT_665], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -61774,311 +54500,631 @@ fn aiur_fn_738(
     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(0);
-    let __io_pair: (G, G) = { let __key: [G; 32] = [__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]; let __info = io_buffer.get_info(__v_32, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) };
-    let __v_33: G = __io_pair.0;
-    let __v_34: G = __io_pair.1;
-    let __v_35: G = G::from_u64(0);
-    let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_35, __v_33, __v_34]; let __cu = true; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { let __ret: [G; OUT_0] = unsafe { *(result.output.as_ptr() as *const [G; OUT_0]) }; __ret } else { aiur_fn_0(__args, record, io_buffer, __cu)? } };
-    let __v_36: G = __r_arr[0];
-    let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_36, __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]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } else { aiur_fn_15(__args, record, io_buffer, __cu)? } };
-    let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[737].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = unsafe { *(result.output.as_ptr() as *const [G; OUT_737]) }; __ret } else { aiur_fn_737(__args, record, io_buffer, __cu)? } };
-    let __v_37: G = __r_arr[0];
-    let __v_38: G = __r_arr[1];
-    let __v_39: G = __r_arr[2];
-    let __v_40: G = __r_arr[3];
-    let __v_41: G = __r_arr[4];
-    let __v_42: G = __r_arr[5];
-    let __v_43: G = __r_arr[6];
-    let __v_44: G = __r_arr[7];
-    let __v_45: G = __r_arr[8];
-    let __v_46: G = __r_arr[9];
-    let __v_47: G = __r_arr[10];
-    let __v_48: G = __r_arr[11];
-    let __v_49: G = __r_arr[12];
-    let __v_50: G = __r_arr[13];
-    let __v_51: G = __r_arr[14];
-    let __v_52: G = __r_arr[15];
-    let __v_53: G = __r_arr[16];
-    let __v_54: G = __r_arr[17];
-    let __v_55: G = __r_arr[18];
-    let __v_56: G = __r_arr[19];
-    let __v_57: G = __r_arr[20];
-    let __v_58: G = __r_arr[21];
-    let __v_59: G = __r_arr[22];
-    let __v_60: G = __r_arr[23];
-    let __v_61: G = __r_arr[24];
-    let __v_62: G = __r_arr[25];
-    let __v_63: G = __r_arr[26];
-    let __v_64: G = __r_arr[27];
-    let __v_65: G = __r_arr[28];
-    let __v_66: G = __r_arr[29];
-    let __v_67: G = __r_arr[30];
-    let __v_68: G = __r_arr[31];
-    let __v_69: G = __r_arr[32];
-    let __v_70: G = __r_arr[33];
-    let __v_71: G = __r_arr[34];
-    let __v_72: G = __r_arr[35];
-    let __v_73: G = __r_arr[36];
-    let __v_74: G = __r_arr[37];
-    let __v_75: G = __r_arr[38];
-    let __v_76: G = __r_arr[39];
-    let __v_77: G = __r_arr[40];
-    let __v_78: G = __r_arr[41];
-    let __v_79: G = __r_arr[42];
-    let __v_80: G = __r_arr[43];
-    let __v_81: G = __r_arr[44];
-    let __v_82: G = __r_arr[45];
-    let __v_83: G = __r_arr[46];
-    let __v_84: G = __r_arr[47];
-    let __v_85: G = __r_arr[48];
-    let __v_86: G = __r_arr[49];
-    let __v_87: G = __r_arr[50];
-    let __v_88: G = __r_arr[51];
-    let __v_89: G = __r_arr[52];
-    let __v_90: G = __r_arr[53];
-    let __v_91: G = __r_arr[54];
-    let __v_92: G = __r_arr[55];
-    let __v_93: G = __r_arr[56];
-    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];
-    let __v_97: G = G::from_u64(1);
-    let __v_98: G = G::from_u64(1);
-    if (__v_94 != __v_97) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_94.as_canonical_u64(), rhs: __v_97.as_canonical_u64() });
-    }
-    if (__v_95 != __v_98) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_95.as_canonical_u64(), rhs: __v_98.as_canonical_u64() });
-    }
-    if (__v_96 != __v_98) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_96.as_canonical_u64(), rhs: __v_98.as_canonical_u64() });
-    }
-    let __ret: [G; OUT_738] = [__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];
-    record.function_queries[738].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_13: G = __loaded[0];
+    let __v_14: G = __loaded[1];
+    let __v_15: G = __loaded[2];
+    match __v_13.as_canonical_u64() {
+      1u64 => {
+        let __ret: [G; OUT_665] = [];
+        record.function_queries[665].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __v_16: G = G::from_u64(1);
+        let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_14, __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_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[663].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_663] = unsafe { *(result.output.as_ptr() as *const [G; OUT_663]) }; __ret } else { aiur_fn_663(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_665] = { let __args: [G; IN_665] = [__v_15, __v_1, __v_2, __v_3, __v_4, __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[665].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_665] = unsafe { *(result.output.as_ptr() as *const [G; OUT_665]) }; __ret } else { aiur_fn_665(__args, record, io_buffer, __cu)? } };
+        let __ret: [G; OUT_665] = [];
+        record.function_queries[665].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64()));
+      },
+    }
   })
 }
 
-const INPUT_SIZE_739: usize = 1;
-const IN_739: usize = 1;
-const OUT_739: usize = 1;
-fn aiur_fn_739(
-  inp: [G; IN_739],
+const INPUT_SIZE_666: usize = 3;
+const IN_666: usize = 3;
+const OUT_666: usize = 0;
+fn aiur_fn_666(
+  inp: [G; IN_666],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_739], ExecError> {
+) -> Result<[G; OUT_666], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; 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: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].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 = G::from_u64(1);
-    let __v_20: G = G::from_u64(1);
-    let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __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 __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__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_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { 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_22: G = __r_arr[0];
-    let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } else { aiur_fn_16(__args, record, io_buffer, __cu)? } };
-    let __v_23: G = __r_arr[0];
-    let __ret: [G; OUT_739] = [__v_23];
-    record.function_queries[739].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } };
+    let __v_3: G = __r_arr[0];
+    let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_1.as_canonical_u64() {
+  1u64 => {
+    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 } };
+    break '__mc_0 [__v_6];
+  },
+  0u64 => {
+    let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } };
+    let __v_4: G = __r_arr[0];
+    break '__mc_0 [__v_4];
+  },
+  _ => {
+    return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+  },
+}
+ };
+    let __v_4: G = __mc_out___mc_0[0];
+    let __v_5: G = G::from_u64(1);
+    let __v_6: G = G::from_u64(1);
+    let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_3, __v_5, __v_6, __v_6, __v_6, __v_6, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[661].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_661] = unsafe { *(result.output.as_ptr() as *const [G; OUT_661]) }; __ret } else { aiur_fn_661(__args, record, io_buffer, __cu)? } };
+    let __v_7: G = __r_arr[0];
+    let __v_8: G = __r_arr[1];
+    let __v_9: G = __r_arr[2];
+    let __v_10: G = __r_arr[3];
+    let __v_11: G = __r_arr[4];
+    let __v_12: G = __r_arr[5];
+    let __v_13: G = G::from_u64(1);
+    let __v_14: G = G::from_u64(1);
+    let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_4, __v_13, __v_14, __v_14, __v_14, __v_14, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[661].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_661] = unsafe { *(result.output.as_ptr() as *const [G; OUT_661]) }; __ret } else { aiur_fn_661(__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 __r_arr: [G; OUT_665] = { let __args: [G; IN_665] = [__v_3, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[665].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_665] = unsafe { *(result.output.as_ptr() as *const [G; OUT_665]) }; __ret } else { aiur_fn_665(__args, record, io_buffer, __cu)? } };
+    let __ret: [G; OUT_666] = [];
+    record.function_queries[666].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_740: usize = 1;
-const IN_740: usize = 1;
-const OUT_740: usize = 1;
-fn aiur_fn_740(
-  inp: [G; IN_740],
+const INPUT_SIZE_667: usize = 1;
+const IN_667: usize = 1;
+const OUT_667: usize = 3;
+fn aiur_fn_667(
+  inp: [G; IN_667],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_740], ExecError> {
+) -> Result<[G; OUT_667], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    match __v_0.as_canonical_u64() {
+    let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { 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_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    match __v_1.as_canonical_u64() {
       0u64 => {
-        let __v_1: G = G::from_u64(0);
-        let __ret: [G; OUT_740] = [__v_1];
-        record.function_queries[740].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __v_3: G = G::from_u64(1);
+        let __v_4: G = G::from_u64(1);
+        let __ret: [G; OUT_667] = [__v_3, __v_4, __v_2];
+        record.function_queries[667].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       1u64 => {
-        let __v_1: G = G::from_u64(1);
-        let __ret: [G; OUT_740] = [__v_1];
-        record.function_queries[740].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[81].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_81] = unsafe { *(result.output.as_ptr() as *const [G; OUT_81]) }; __ret } else { aiur_fn_81(__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(0);
+        let __ret: [G; OUT_667] = [__v_5, __v_3, __v_4];
+        record.function_queries[667].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      2u64 => {
-        let __v_1: G = G::from_u64(2);
-        let __ret: [G; OUT_740] = [__v_1];
-        record.function_queries[740].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_668: usize = 2;
+const IN_668: usize = 2;
+const OUT_668: usize = 10;
+fn aiur_fn_668(
+  inp: [G; IN_668],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_668], 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(1);
+        let __v_3: G = G::from_u64(1);
+        let __ret: [G; OUT_668] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_1];
+        record.function_queries[668].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64()));
+        let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[70].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_70] = unsafe { *(result.output.as_ptr() as *const [G; OUT_70]) }; __ret } else { aiur_fn_70(__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(0);
+        let __ret: [G; OUT_668] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10];
+        record.function_queries[668].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_741: usize = 3;
-const IN_741: usize = 3;
-const OUT_741: usize = 0;
-fn aiur_fn_741(
-  inp: [G; IN_741],
+const INPUT_SIZE_669: usize = 2;
+const IN_669: usize = 2;
+const OUT_669: usize = 3;
+fn aiur_fn_669(
+  inp: [G; IN_669],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_741], ExecError> {
+) -> Result<[G; OUT_669], 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_1.as_canonical_u64() {
-      1u64 => {
-        let __ret: [G; OUT_741] = [];
-        record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __v_2: G = G::from_u64(1);
+        let __v_3: G = G::from_u64(1);
+        let __ret: [G; OUT_669] = [__v_2, __v_3, __v_1];
+        record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[81].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_81] = unsafe { *(result.output.as_ptr() as *const [G; OUT_81]) }; __ret } else { aiur_fn_81(__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(0);
+        let __ret: [G; OUT_669] = [__v_4, __v_2, __v_3];
+        record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
+    }
+  })
+}
+
+const INPUT_SIZE_670: usize = 2;
+const IN_670: usize = 2;
+const OUT_670: usize = 3;
+fn aiur_fn_670(
+  inp: [G; IN_670],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_670], 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 __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } else { aiur_fn_740(__args, record, io_buffer, __cu)? } };
-        let __v_3: G = __r_arr[0];
-        let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } else { aiur_fn_740(__args, record, io_buffer, __cu)? } };
-        let __v_4: G = __r_arr[0];
-        if (__v_3 != __v_4) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_4.as_canonical_u64() });
-        }
-        let __ret: [G; OUT_741] = [];
-        record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __v_2: G = G::from_u64(1);
+        let __v_3: G = G::from_u64(1);
+        let __ret: [G; OUT_670] = [__v_2, __v_3, __v_1];
+        record.function_queries[670].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+        let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { 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_2: G = __r_arr[0];
+        let __v_3: G = __r_arr[1];
+        let __v_4: G = G::from_u64(0);
+        let __ret: [G; OUT_670] = [__v_4, __v_2, __v_3];
+        record.function_queries[670].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_742: usize = 3;
-const IN_742: usize = 3;
-const OUT_742: usize = 0;
-fn aiur_fn_742(
-  inp: [G; IN_742],
+const INPUT_SIZE_671: usize = 2;
+const IN_671: usize = 2;
+const OUT_671: usize = 3;
+fn aiur_fn_671(
+  inp: [G; IN_671],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_742], ExecError> {
+) -> Result<[G; OUT_671], 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_1.as_canonical_u64() {
-      1u64 => {
-        let __ret: [G; OUT_742] = [];
-        record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __v_2: G = G::from_u64(1);
+        let __v_3: G = G::from_u64(1);
+        let __ret: [G; OUT_671] = [__v_2, __v_3, __v_1];
+        record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[92].get_mut(&__args[..]) { 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_3: G = __r_arr[0];
-        let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[92].get_mut(&__args[..]) { 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_4: G = __r_arr[0];
-        if (__v_3 != __v_4) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_4.as_canonical_u64() });
+      _ => {
+        let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { 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_2: G = __r_arr[0];
+        let __v_3: G = __r_arr[1];
+        match __v_2.as_canonical_u64() {
+          0u64 => {
+            let __v_4: G = G::from_u64(0);
+            let __v_5: G = G::from_u64(0);
+            let __ret: [G; OUT_671] = [__v_4, __v_5, __v_3];
+            record.function_queries[671].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 __ret: [G; OUT_671] = [__v_4, __v_5, __v_3];
+            record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          2u64 => {
+            let __v_4: G = G::from_u64(0);
+            let __v_5: G = G::from_u64(2);
+            let __ret: [G; OUT_671] = [__v_4, __v_5, __v_3];
+            record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+          },
         }
-        let __ret: [G; OUT_742] = [];
-        record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_672: usize = 2;
+const IN_672: usize = 2;
+const OUT_672: usize = 3;
+fn aiur_fn_672(
+  inp: [G; IN_672],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_672], 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(1);
+        let __v_3: G = G::from_u64(1);
+        let __ret: [G; OUT_672] = [__v_2, __v_3, __v_1];
+        record.function_queries[672].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+        let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { 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_2: G = __r_arr[0];
+        let __v_3: G = __r_arr[1];
+        match __v_2.as_canonical_u64() {
+          0u64 => {
+            let __v_4: G = G::from_u64(0);
+            let __v_5: G = G::from_u64(0);
+            let __ret: [G; OUT_672] = [__v_4, __v_5, __v_3];
+            record.function_queries[672].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 __ret: [G; OUT_672] = [__v_4, __v_5, __v_3];
+            record.function_queries[672].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          2u64 => {
+            let __v_4: G = G::from_u64(0);
+            let __v_5: G = G::from_u64(2);
+            let __ret: [G; OUT_672] = [__v_4, __v_5, __v_3];
+            record.function_queries[672].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          3u64 => {
+            let __v_4: G = G::from_u64(0);
+            let __v_5: G = G::from_u64(3);
+            let __ret: [G; OUT_672] = [__v_4, __v_5, __v_3];
+            record.function_queries[672].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+          },
+        }
       },
     }
   })
 }
 
-const INPUT_SIZE_743: usize = 3;
-const IN_743: usize = 3;
-const OUT_743: usize = 0;
-fn aiur_fn_743(
-  inp: [G; IN_743],
+const INPUT_SIZE_673: usize = 9;
+const IN_673: usize = 9;
+const OUT_673: usize = 2;
+fn aiur_fn_673(
+  inp: [G; IN_673],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_743], ExecError> {
+) -> Result<[G; OUT_673], 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_1.as_canonical_u64() {
+    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_4] = { let __args: [G; IN_4] = [__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[4].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } else { aiur_fn_4(__args, record, io_buffer, __cu)? } };
+    let __v_9: G = __r_arr[0];
+    match __v_9.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_743] = [];
-        record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __v_10: G = G::from_u64(1);
+        let __v_11: G = G::from_u64(1);
+        let __v_12: G = { let __values: [G; 19] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&19).ok_or(ExecError::InvalidMemorySize(19))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_673] = [__v_12, __v_0];
+        record.function_queries[673].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_100] = { let __args: [G; IN_100] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[100].get_mut(&__args[..]) { 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_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 = __r_arr[9];
+        let __v_20: G = __r_arr[10];
+        let __v_21: G = __r_arr[11];
+        let __v_22: G = __r_arr[12];
+        let __v_23: G = __r_arr[13];
+        let __v_24: G = __r_arr[14];
+        let __v_25: G = __r_arr[15];
+        let __v_26: G = __r_arr[16];
+        let __v_27: G = __r_arr[17];
+        let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__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[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__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 __r_arr: [G; OUT_673] = { let __args: [G; IN_673] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[673].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_673] = unsafe { *(result.output.as_ptr() as *const [G; OUT_673]) }; __ret } else { aiur_fn_673(__args, record, io_buffer, __cu)? } };
+        let __v_36: G = __r_arr[0];
+        let __v_37: G = __r_arr[1];
+        let __v_38: G = G::from_u64(0);
+        let __v_39: G = { let __values: [G; 19] = [__v_38, __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_36]; let __mq = record.memory_queries.get_mut(&19).ok_or(ExecError::InvalidMemorySize(19))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_673] = [__v_39, __v_37];
+        record.function_queries[673].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
+    }
+  })
+}
+
+const INPUT_SIZE_674: usize = 2;
+const IN_674: usize = 2;
+const OUT_674: usize = 3;
+fn aiur_fn_674(
+  inp: [G; IN_674],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_674], 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 => {
-        if (__v_0 != __v_2) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_0.as_canonical_u64(), rhs: __v_2.as_canonical_u64() });
-        }
-        let __ret: [G; OUT_743] = [];
-        record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __v_2: G = G::from_u64(1);
+        let __v_3: G = G::from_u64(1);
+        let __ret: [G; OUT_674] = [__v_2, __v_3, __v_1];
+        record.function_queries[674].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+        let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[70].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_70] = unsafe { *(result.output.as_ptr() as *const [G; OUT_70]) }; __ret } else { aiur_fn_70(__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_673] = { let __args: [G; IN_673] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[673].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_673] = unsafe { *(result.output.as_ptr() as *const [G; OUT_673]) }; __ret } else { aiur_fn_673(__args, record, io_buffer, __cu)? } };
+        let __v_11: G = __r_arr[0];
+        let __v_12: G = __r_arr[1];
+        let __v_13: G = G::from_u64(0);
+        let __ret: [G; OUT_674] = [__v_13, __v_11, __v_12];
+        record.function_queries[674].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_744: usize = 17;
-const IN_744: usize = 17;
-const OUT_744: usize = 0;
-fn aiur_fn_744(
-  inp: [G; IN_744],
+const INPUT_SIZE_675: usize = 1;
+const IN_675: usize = 1;
+const OUT_675: usize = 41;
+fn aiur_fn_675(
+  inp: [G; IN_675],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_675], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[70].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_70] = unsafe { *(result.output.as_ptr() as *const [G; OUT_70]) }; __ret } else { aiur_fn_70(__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 __b1_out: [G; 8] = if unconstrained { let __v: Vec<G> = Bytes1::bit_decompose(&__v_1); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_1, record) };
+    let __v_10: G = __b1_out[0];
+    let __v_11: G = __b1_out[1];
+    let __v_12: G = __b1_out[2];
+    let __v_13: G = __b1_out[3];
+    let __v_14: G = __b1_out[4];
+    let __v_15: G = __b1_out[5];
+    let __v_16: G = __b1_out[6];
+    let __v_17: G = __b1_out[7];
+    let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_10, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[670].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_670] = unsafe { *(result.output.as_ptr() as *const [G; OUT_670]) }; __ret } else { aiur_fn_670(__args, record, io_buffer, __cu)? } };
+    let __v_18: G = __r_arr[0];
+    let __v_19: G = __r_arr[1];
+    let __v_20: G = __r_arr[2];
+    let __r_arr: [G; OUT_668] = { let __args: [G; IN_668] = [__v_11, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[668].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_668] = unsafe { *(result.output.as_ptr() as *const [G; OUT_668]) }; __ret } else { aiur_fn_668(__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_668] = { let __args: [G; IN_668] = [__v_12, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[668].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_668] = unsafe { *(result.output.as_ptr() as *const [G; OUT_668]) }; __ret } else { aiur_fn_668(__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_668] = { let __args: [G; IN_668] = [__v_13, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[668].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_668] = unsafe { *(result.output.as_ptr() as *const [G; OUT_668]) }; __ret } else { aiur_fn_668(__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_668] = { let __args: [G; IN_668] = [__v_14, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[668].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_668] = unsafe { *(result.output.as_ptr() as *const [G; OUT_668]) }; __ret } else { aiur_fn_668(__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_669] = { let __args: [G; IN_669] = [__v_15, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[669].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_669] = unsafe { *(result.output.as_ptr() as *const [G; OUT_669]) }; __ret } else { aiur_fn_669(__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 __ret: [G; OUT_675] = [__v_18, __v_19, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_61, __v_62, __v_63];
+    record.function_queries[675].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_676: usize = 1;
+const IN_676: usize = 1;
+const OUT_676: usize = 49;
+fn aiur_fn_676(
+  inp: [G; IN_676],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_676], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[70].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_70] = unsafe { *(result.output.as_ptr() as *const [G; OUT_70]) }; __ret } else { aiur_fn_70(__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_675] = { let __args: [G; IN_675] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } else { aiur_fn_675(__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 = __r_arr[9];
+    let __v_20: G = __r_arr[10];
+    let __v_21: G = __r_arr[11];
+    let __v_22: G = __r_arr[12];
+    let __v_23: G = __r_arr[13];
+    let __v_24: G = __r_arr[14];
+    let __v_25: G = __r_arr[15];
+    let __v_26: G = __r_arr[16];
+    let __v_27: G = __r_arr[17];
+    let __v_28: G = __r_arr[18];
+    let __v_29: G = __r_arr[19];
+    let __v_30: G = __r_arr[20];
+    let __v_31: G = __r_arr[21];
+    let __v_32: G = __r_arr[22];
+    let __v_33: G = __r_arr[23];
+    let __v_34: G = __r_arr[24];
+    let __v_35: G = __r_arr[25];
+    let __v_36: G = __r_arr[26];
+    let __v_37: G = __r_arr[27];
+    let __v_38: G = __r_arr[28];
+    let __v_39: G = __r_arr[29];
+    let __v_40: G = __r_arr[30];
+    let __v_41: G = __r_arr[31];
+    let __v_42: G = __r_arr[32];
+    let __v_43: G = __r_arr[33];
+    let __v_44: G = __r_arr[34];
+    let __v_45: G = __r_arr[35];
+    let __v_46: G = __r_arr[36];
+    let __v_47: G = __r_arr[37];
+    let __v_48: G = __r_arr[38];
+    let __v_49: G = __r_arr[39];
+    let __v_50: G = __r_arr[40];
+    let __ret: [G; OUT_676] = [__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_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];
+    record.function_queries[676].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_677: usize = 9;
+const IN_677: usize = 9;
+const OUT_677: usize = 2;
+fn aiur_fn_677(
+  inp: [G; IN_677],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_744], ExecError> {
+) -> Result<[G; OUT_677], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -62089,435 +55135,337 @@ fn aiur_fn_744(
     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];
-    match __v_8.as_canonical_u64() {
+    let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__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[4].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } else { aiur_fn_4(__args, record, io_buffer, __cu)? } };
+    let __v_9: G = __r_arr[0];
+    match __v_9.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_744] = [];
-        record.function_queries[744].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      0u64 => {
-        if (__v_0 != __v_9) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_0.as_canonical_u64(), rhs: __v_9.as_canonical_u64() });
-        }
-        if (__v_1 != __v_10) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_1.as_canonical_u64(), rhs: __v_10.as_canonical_u64() });
-        }
-        if (__v_2 != __v_11) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_2.as_canonical_u64(), rhs: __v_11.as_canonical_u64() });
-        }
-        if (__v_3 != __v_12) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_12.as_canonical_u64() });
-        }
-        if (__v_4 != __v_13) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_4.as_canonical_u64(), rhs: __v_13.as_canonical_u64() });
-        }
-        if (__v_5 != __v_14) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_14.as_canonical_u64() });
-        }
-        if (__v_6 != __v_15) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_15.as_canonical_u64() });
-        }
-        if (__v_7 != __v_16) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_16.as_canonical_u64() });
-        }
-        let __ret: [G; OUT_744] = [];
-        record.function_queries[744].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __v_10: G = G::from_u64(1);
+        let __v_11: G = G::from_u64(1);
+        let __v_12: G = { let __values: [G; 50] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&50).ok_or(ExecError::InvalidMemorySize(50))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_677] = [__v_12, __v_0];
+        record.function_queries[677].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64()));
+        let __r_arr: [G; OUT_676] = { let __args: [G; IN_676] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[676].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_676] = unsafe { *(result.output.as_ptr() as *const [G; OUT_676]) }; __ret } else { aiur_fn_676(__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 = __r_arr[9];
+        let __v_20: G = __r_arr[10];
+        let __v_21: G = __r_arr[11];
+        let __v_22: G = __r_arr[12];
+        let __v_23: G = __r_arr[13];
+        let __v_24: G = __r_arr[14];
+        let __v_25: G = __r_arr[15];
+        let __v_26: G = __r_arr[16];
+        let __v_27: G = __r_arr[17];
+        let __v_28: G = __r_arr[18];
+        let __v_29: G = __r_arr[19];
+        let __v_30: G = __r_arr[20];
+        let __v_31: G = __r_arr[21];
+        let __v_32: G = __r_arr[22];
+        let __v_33: G = __r_arr[23];
+        let __v_34: G = __r_arr[24];
+        let __v_35: G = __r_arr[25];
+        let __v_36: G = __r_arr[26];
+        let __v_37: G = __r_arr[27];
+        let __v_38: G = __r_arr[28];
+        let __v_39: G = __r_arr[29];
+        let __v_40: G = __r_arr[30];
+        let __v_41: G = __r_arr[31];
+        let __v_42: G = __r_arr[32];
+        let __v_43: G = __r_arr[33];
+        let __v_44: G = __r_arr[34];
+        let __v_45: G = __r_arr[35];
+        let __v_46: G = __r_arr[36];
+        let __v_47: G = __r_arr[37];
+        let __v_48: G = __r_arr[38];
+        let __v_49: G = __r_arr[39];
+        let __v_50: G = __r_arr[40];
+        let __v_51: G = __r_arr[41];
+        let __v_52: G = __r_arr[42];
+        let __v_53: G = __r_arr[43];
+        let __v_54: G = __r_arr[44];
+        let __v_55: G = __r_arr[45];
+        let __v_56: G = __r_arr[46];
+        let __v_57: G = __r_arr[47];
+        let __v_58: G = __r_arr[48];
+        let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__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[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__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 __r_arr: [G; OUT_677] = { let __args: [G; IN_677] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66]; let __cu = unconstrained; if let Some(result) = record.function_queries[677].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_677] = unsafe { *(result.output.as_ptr() as *const [G; OUT_677]) }; __ret } else { aiur_fn_677(__args, record, io_buffer, __cu)? } };
+        let __v_67: G = __r_arr[0];
+        let __v_68: G = __r_arr[1];
+        let __v_69: G = G::from_u64(0);
+        let __v_70: G = { let __values: [G; 50] = [__v_69, __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_67]; let __mq = record.memory_queries.get_mut(&50).ok_or(ExecError::InvalidMemorySize(50))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_677] = [__v_70, __v_68];
+        record.function_queries[677].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_745: usize = 3;
-const IN_745: usize = 3;
-const OUT_745: usize = 0;
-fn aiur_fn_745(
-  inp: [G; IN_745],
+const INPUT_SIZE_678: usize = 2;
+const IN_678: usize = 2;
+const OUT_678: usize = 3;
+fn aiur_fn_678(
+  inp: [G; IN_678],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_745], ExecError> {
+) -> Result<[G; OUT_678], 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_1.as_canonical_u64() {
-      1u64 => {
-        let __ret: [G; OUT_745] = [];
-        record.function_queries[745].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
+    match __v_0.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_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_3: G = __loaded[0];
-        let __v_4: G = __loaded[1];
-        let __v_5: G = __loaded[2];
-        let __v_6: G = __loaded[3];
-        let __v_7: G = __loaded[4];
-        let __v_8: G = __loaded[5];
-        let __v_9: G = __loaded[6];
-        let __v_10: G = __loaded[7];
-        let __v_11: G = __loaded[8];
-        let __v_12: G = __loaded[9];
-        let __v_13: G = __loaded[10];
-        let __v_14: G = __loaded[11];
-        let __v_15: G = __loaded[12];
-        let __v_16: G = __loaded[13];
-        let __v_17: G = __loaded[14];
-        let __v_18: G = __loaded[15];
-        let __v_19: G = __loaded[16];
-        let __v_20: G = __loaded[17];
-        let __v_21: G = __loaded[18];
-        let __v_22: G = __loaded[19];
-        let __v_23: G = __loaded[20];
-        let __v_24: G = __loaded[21];
-        let __v_25: G = __loaded[22];
-        let __v_26: G = __loaded[23];
-        let __v_27: G = __loaded[24];
-        let __v_28: G = __loaded[25];
-        let __v_29: G = __loaded[26];
-        let __v_30: G = __loaded[27];
-        let __v_31: G = __loaded[28];
-        let __v_32: G = __loaded[29];
-        let __v_33: G = __loaded[30];
-        let __v_34: G = __loaded[31];
-        let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; 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: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].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];
-        if (__v_3 != __v_35) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_35.as_canonical_u64() });
-        }
-        if (__v_4 != __v_36) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_4.as_canonical_u64(), rhs: __v_36.as_canonical_u64() });
-        }
-        if (__v_5 != __v_37) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_37.as_canonical_u64() });
-        }
-        if (__v_6 != __v_38) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_38.as_canonical_u64() });
-        }
-        if (__v_7 != __v_39) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_39.as_canonical_u64() });
-        }
-        if (__v_8 != __v_40) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_8.as_canonical_u64(), rhs: __v_40.as_canonical_u64() });
-        }
-        if (__v_9 != __v_41) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_41.as_canonical_u64() });
-        }
-        if (__v_10 != __v_42) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_10.as_canonical_u64(), rhs: __v_42.as_canonical_u64() });
-        }
-        if (__v_11 != __v_43) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_43.as_canonical_u64() });
-        }
-        if (__v_12 != __v_44) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_12.as_canonical_u64(), rhs: __v_44.as_canonical_u64() });
-        }
-        if (__v_13 != __v_45) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_45.as_canonical_u64() });
-        }
-        if (__v_14 != __v_46) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_14.as_canonical_u64(), rhs: __v_46.as_canonical_u64() });
-        }
-        if (__v_15 != __v_47) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_15.as_canonical_u64(), rhs: __v_47.as_canonical_u64() });
-        }
-        if (__v_16 != __v_48) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_48.as_canonical_u64() });
-        }
-        if (__v_17 != __v_49) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_17.as_canonical_u64(), rhs: __v_49.as_canonical_u64() });
-        }
-        if (__v_18 != __v_50) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_18.as_canonical_u64(), rhs: __v_50.as_canonical_u64() });
-        }
-        if (__v_19 != __v_51) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_19.as_canonical_u64(), rhs: __v_51.as_canonical_u64() });
-        }
-        if (__v_20 != __v_52) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_20.as_canonical_u64(), rhs: __v_52.as_canonical_u64() });
-        }
-        if (__v_21 != __v_53) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_21.as_canonical_u64(), rhs: __v_53.as_canonical_u64() });
-        }
-        if (__v_22 != __v_54) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_22.as_canonical_u64(), rhs: __v_54.as_canonical_u64() });
-        }
-        if (__v_23 != __v_55) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_23.as_canonical_u64(), rhs: __v_55.as_canonical_u64() });
-        }
-        if (__v_24 != __v_56) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_24.as_canonical_u64(), rhs: __v_56.as_canonical_u64() });
-        }
-        if (__v_25 != __v_57) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_25.as_canonical_u64(), rhs: __v_57.as_canonical_u64() });
-        }
-        if (__v_26 != __v_58) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_26.as_canonical_u64(), rhs: __v_58.as_canonical_u64() });
-        }
-        if (__v_27 != __v_59) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_27.as_canonical_u64(), rhs: __v_59.as_canonical_u64() });
-        }
-        if (__v_28 != __v_60) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_28.as_canonical_u64(), rhs: __v_60.as_canonical_u64() });
-        }
-        if (__v_29 != __v_61) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_29.as_canonical_u64(), rhs: __v_61.as_canonical_u64() });
-        }
-        if (__v_30 != __v_62) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_30.as_canonical_u64(), rhs: __v_62.as_canonical_u64() });
-        }
-        if (__v_31 != __v_63) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_31.as_canonical_u64(), rhs: __v_63.as_canonical_u64() });
-        }
-        if (__v_32 != __v_64) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_32.as_canonical_u64(), rhs: __v_64.as_canonical_u64() });
-        }
-        if (__v_33 != __v_65) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_33.as_canonical_u64(), rhs: __v_65.as_canonical_u64() });
-        }
-        if (__v_34 != __v_66) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_34.as_canonical_u64(), rhs: __v_66.as_canonical_u64() });
-        }
-        let __ret: [G; OUT_745] = [];
-        record.function_queries[745].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __v_2: G = G::from_u64(1);
+        let __v_3: G = G::from_u64(1);
+        let __ret: [G; OUT_678] = [__v_2, __v_3, __v_1];
+        record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+        let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[70].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_70] = unsafe { *(result.output.as_ptr() as *const [G; OUT_70]) }; __ret } else { aiur_fn_70(__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_677] = { let __args: [G; IN_677] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[677].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_677] = unsafe { *(result.output.as_ptr() as *const [G; OUT_677]) }; __ret } else { aiur_fn_677(__args, record, io_buffer, __cu)? } };
+        let __v_11: G = __r_arr[0];
+        let __v_12: G = __r_arr[1];
+        let __v_13: G = G::from_u64(0);
+        let __ret: [G; OUT_678] = [__v_13, __v_11, __v_12];
+        record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_746: usize = 3;
-const IN_746: usize = 3;
-const OUT_746: usize = 0;
-fn aiur_fn_746(
-  inp: [G; IN_746],
+const INPUT_SIZE_679: usize = 1;
+const IN_679: usize = 1;
+const OUT_679: usize = 55;
+fn aiur_fn_679(
+  inp: [G; IN_679],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_746], ExecError> {
+) -> Result<[G; OUT_679], 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_68] = { let __args: [G; IN_68] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { 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_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[70].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_70] = unsafe { *(result.output.as_ptr() as *const [G; OUT_70]) }; __ret } else { aiur_fn_70(__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 __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_12: G = __b1_out[0];
+    let __v_13: G = __b1_out[1];
+    let __v_14: G = __b1_out[2];
+    let __v_15: G = __b1_out[3];
+    let __v_16: G = __b1_out[4];
+    let __v_17: G = __b1_out[5];
+    let __v_18: G = __b1_out[6];
+    let __v_19: 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_20: G = __b1_out[0];
+    let __v_21: G = __b1_out[1];
+    let __v_22: G = __b1_out[2];
+    let __v_23: G = __b1_out[3];
+    let __v_24: G = __b1_out[4];
+    let __v_25: G = __b1_out[5];
+    let __v_26: G = __b1_out[6];
+    let __v_27: G = __b1_out[7];
     match __v_1.as_canonical_u64() {
-      1u64 => {
-        let __ret: [G; OUT_746] = [];
-        record.function_queries[746].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+      0u64 => {
+        let __r_arr: [G; OUT_671] = { let __args: [G; IN_671] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[671].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_671] = unsafe { *(result.output.as_ptr() as *const [G; OUT_671]) }; __ret } else { aiur_fn_671(__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 __r_arr: [G; OUT_671] = { let __args: [G; IN_671] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[671].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_671] = unsafe { *(result.output.as_ptr() as *const [G; OUT_671]) }; __ret } else { aiur_fn_671(__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 __r_arr: [G; OUT_668] = { let __args: [G; IN_668] = [__v_14, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[668].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_668] = unsafe { *(result.output.as_ptr() as *const [G; OUT_668]) }; __ret } else { aiur_fn_668(__args, record, io_buffer, __cu)? } };
+        let __v_34: G = __r_arr[0];
+        let __v_35: G = __r_arr[1];
+        let __v_36: G = __r_arr[2];
+        let __v_37: G = __r_arr[3];
+        let __v_38: G = __r_arr[4];
+        let __v_39: G = __r_arr[5];
+        let __v_40: G = __r_arr[6];
+        let __v_41: G = __r_arr[7];
+        let __v_42: G = __r_arr[8];
+        let __v_43: G = __r_arr[9];
+        let __r_arr: [G; OUT_669] = { let __args: [G; IN_669] = [__v_15, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[669].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_669] = unsafe { *(result.output.as_ptr() as *const [G; OUT_669]) }; __ret } else { aiur_fn_669(__args, record, io_buffer, __cu)? } };
+        let __v_44: G = __r_arr[0];
+        let __v_45: G = __r_arr[1];
+        let __v_46: G = __r_arr[2];
+        let __r_arr: [G; OUT_669] = { let __args: [G; IN_669] = [__v_16, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[669].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_669] = unsafe { *(result.output.as_ptr() as *const [G; OUT_669]) }; __ret } else { aiur_fn_669(__args, record, io_buffer, __cu)? } };
+        let __v_47: G = __r_arr[0];
+        let __v_48: G = __r_arr[1];
+        let __v_49: G = __r_arr[2];
+        let __v_50: G = G::from_u64(0);
+        let __v_51: G = G::from_u64(0);
+        let __ret: [G; OUT_679] = [__v_50, __v_28, __v_29, __v_31, __v_32, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_44, __v_45, __v_47, __v_48, __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, __v_51, __v_51, __v_51, __v_49];
+        record.function_queries[679].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __r_arr: [G; OUT_739] = { let __args: [G; IN_739] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[739].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_739] = unsafe { *(result.output.as_ptr() as *const [G; OUT_739]) }; __ret } else { aiur_fn_739(__args, record, io_buffer, __cu)? } };
-        let __v_3: G = __r_arr[0];
-        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_4: G = __loaded[0];
-        let __v_5: G = __loaded[1];
-        let __v_6: G = __loaded[2];
-        let __v_7: G = __loaded[3];
-        let __v_8: G = __loaded[4];
-        let __v_9: G = __loaded[5];
-        let __v_10: G = __loaded[6];
-        let __v_11: G = __loaded[7];
-        let __v_12: G = __loaded[8];
-        let __v_13: G = __loaded[9];
-        let __v_14: G = __loaded[10];
-        let __v_15: G = __loaded[11];
-        let __v_16: G = __loaded[12];
-        let __v_17: G = __loaded[13];
-        let __v_18: G = __loaded[14];
-        let __v_19: G = __loaded[15];
-        let __v_20: G = __loaded[16];
-        let __v_21: G = __loaded[17];
-        let __v_22: G = __loaded[18];
-        let __v_23: G = __loaded[19];
-        let __v_24: G = __loaded[20];
-        let __v_25: G = __loaded[21];
-        let __v_26: G = __loaded[22];
-        let __v_27: G = __loaded[23];
-        let __v_28: G = __loaded[24];
-        let __v_29: G = __loaded[25];
-        let __v_30: G = __loaded[26];
-        let __v_31: G = __loaded[27];
-        let __v_32: G = __loaded[28];
-        let __v_33: G = __loaded[29];
-        let __v_34: G = __loaded[30];
-        let __v_35: G = __loaded[31];
-        let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; 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: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
-        let __v_36: G = __loaded[0];
-        let __v_37: G = __loaded[1];
-        let __v_38: G = __loaded[2];
-        let __v_39: G = __loaded[3];
-        let __v_40: G = __loaded[4];
-        let __v_41: G = __loaded[5];
-        let __v_42: G = __loaded[6];
-        let __v_43: G = __loaded[7];
-        let __v_44: G = __loaded[8];
-        let __v_45: G = __loaded[9];
-        let __v_46: G = __loaded[10];
-        let __v_47: G = __loaded[11];
-        let __v_48: G = __loaded[12];
-        let __v_49: G = __loaded[13];
-        let __v_50: G = __loaded[14];
-        let __v_51: G = __loaded[15];
-        let __v_52: G = __loaded[16];
-        let __v_53: G = __loaded[17];
-        let __v_54: G = __loaded[18];
-        let __v_55: G = __loaded[19];
-        let __v_56: G = __loaded[20];
-        let __v_57: G = __loaded[21];
-        let __v_58: G = __loaded[22];
-        let __v_59: G = __loaded[23];
-        let __v_60: G = __loaded[24];
-        let __v_61: G = __loaded[25];
-        let __v_62: G = __loaded[26];
-        let __v_63: G = __loaded[27];
-        let __v_64: G = __loaded[28];
-        let __v_65: G = __loaded[29];
-        let __v_66: G = __loaded[30];
-        let __v_67: G = __loaded[31];
-        if (__v_4 != __v_36) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_4.as_canonical_u64(), rhs: __v_36.as_canonical_u64() });
-        }
-        if (__v_5 != __v_37) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_37.as_canonical_u64() });
-        }
-        if (__v_6 != __v_38) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_38.as_canonical_u64() });
-        }
-        if (__v_7 != __v_39) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_39.as_canonical_u64() });
-        }
-        if (__v_8 != __v_40) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_8.as_canonical_u64(), rhs: __v_40.as_canonical_u64() });
-        }
-        if (__v_9 != __v_41) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_41.as_canonical_u64() });
-        }
-        if (__v_10 != __v_42) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_10.as_canonical_u64(), rhs: __v_42.as_canonical_u64() });
-        }
-        if (__v_11 != __v_43) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_43.as_canonical_u64() });
-        }
-        if (__v_12 != __v_44) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_12.as_canonical_u64(), rhs: __v_44.as_canonical_u64() });
-        }
-        if (__v_13 != __v_45) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_45.as_canonical_u64() });
-        }
-        if (__v_14 != __v_46) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_14.as_canonical_u64(), rhs: __v_46.as_canonical_u64() });
-        }
-        if (__v_15 != __v_47) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_15.as_canonical_u64(), rhs: __v_47.as_canonical_u64() });
-        }
-        if (__v_16 != __v_48) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_48.as_canonical_u64() });
-        }
-        if (__v_17 != __v_49) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_17.as_canonical_u64(), rhs: __v_49.as_canonical_u64() });
-        }
-        if (__v_18 != __v_50) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_18.as_canonical_u64(), rhs: __v_50.as_canonical_u64() });
-        }
-        if (__v_19 != __v_51) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_19.as_canonical_u64(), rhs: __v_51.as_canonical_u64() });
-        }
-        if (__v_20 != __v_52) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_20.as_canonical_u64(), rhs: __v_52.as_canonical_u64() });
-        }
-        if (__v_21 != __v_53) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_21.as_canonical_u64(), rhs: __v_53.as_canonical_u64() });
-        }
-        if (__v_22 != __v_54) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_22.as_canonical_u64(), rhs: __v_54.as_canonical_u64() });
-        }
-        if (__v_23 != __v_55) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_23.as_canonical_u64(), rhs: __v_55.as_canonical_u64() });
-        }
-        if (__v_24 != __v_56) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_24.as_canonical_u64(), rhs: __v_56.as_canonical_u64() });
-        }
-        if (__v_25 != __v_57) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_25.as_canonical_u64(), rhs: __v_57.as_canonical_u64() });
-        }
-        if (__v_26 != __v_58) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_26.as_canonical_u64(), rhs: __v_58.as_canonical_u64() });
-        }
-        if (__v_27 != __v_59) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_27.as_canonical_u64(), rhs: __v_59.as_canonical_u64() });
-        }
-        if (__v_28 != __v_60) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_28.as_canonical_u64(), rhs: __v_60.as_canonical_u64() });
-        }
-        if (__v_29 != __v_61) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_29.as_canonical_u64(), rhs: __v_61.as_canonical_u64() });
-        }
-        if (__v_30 != __v_62) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_30.as_canonical_u64(), rhs: __v_62.as_canonical_u64() });
-        }
-        if (__v_31 != __v_63) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_31.as_canonical_u64(), rhs: __v_63.as_canonical_u64() });
-        }
-        if (__v_32 != __v_64) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_32.as_canonical_u64(), rhs: __v_64.as_canonical_u64() });
-        }
-        if (__v_33 != __v_65) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_33.as_canonical_u64(), rhs: __v_65.as_canonical_u64() });
-        }
-        if (__v_34 != __v_66) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_34.as_canonical_u64(), rhs: __v_66.as_canonical_u64() });
-        }
-        if (__v_35 != __v_67) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_35.as_canonical_u64(), rhs: __v_67.as_canonical_u64() });
-        }
-        let __ret: [G; OUT_746] = [];
-        record.function_queries[746].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+      1u64 => {
+        let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[670].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_670] = unsafe { *(result.output.as_ptr() as *const [G; OUT_670]) }; __ret } else { aiur_fn_670(__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 __r_arr: [G; OUT_668] = { let __args: [G; IN_668] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[668].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_668] = unsafe { *(result.output.as_ptr() as *const [G; OUT_668]) }; __ret } else { aiur_fn_668(__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_668] = { let __args: [G; IN_668] = [__v_14, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[668].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_668] = unsafe { *(result.output.as_ptr() as *const [G; OUT_668]) }; __ret } else { aiur_fn_668(__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_668] = { let __args: [G; IN_668] = [__v_15, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[668].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_668] = unsafe { *(result.output.as_ptr() as *const [G; OUT_668]) }; __ret } else { aiur_fn_668(__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_669] = { let __args: [G; IN_669] = [__v_16, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[669].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_669] = unsafe { *(result.output.as_ptr() as *const [G; OUT_669]) }; __ret } else { aiur_fn_669(__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 __r_arr: [G; OUT_678] = { let __args: [G; IN_678] = [__v_17, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[678].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_678] = unsafe { *(result.output.as_ptr() as *const [G; OUT_678]) }; __ret } else { aiur_fn_678(__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 = G::from_u64(1);
+        let __v_68: G = G::from_u64(0);
+        let __ret: [G; OUT_679] = [__v_67, __v_28, __v_29, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_61, __v_62, __v_64, __v_65, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_66];
+        record.function_queries[679].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      2u64 => {
+        let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[670].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_670] = unsafe { *(result.output.as_ptr() as *const [G; OUT_670]) }; __ret } else { aiur_fn_670(__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 __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[670].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_670] = unsafe { *(result.output.as_ptr() as *const [G; OUT_670]) }; __ret } else { aiur_fn_670(__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 __r_arr: [G; OUT_668] = { let __args: [G; IN_668] = [__v_14, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[668].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_668] = unsafe { *(result.output.as_ptr() as *const [G; OUT_668]) }; __ret } else { aiur_fn_668(__args, record, io_buffer, __cu)? } };
+        let __v_34: G = __r_arr[0];
+        let __v_35: G = __r_arr[1];
+        let __v_36: G = __r_arr[2];
+        let __v_37: G = __r_arr[3];
+        let __v_38: G = __r_arr[4];
+        let __v_39: G = __r_arr[5];
+        let __v_40: G = __r_arr[6];
+        let __v_41: G = __r_arr[7];
+        let __v_42: G = __r_arr[8];
+        let __v_43: G = __r_arr[9];
+        let __r_arr: [G; OUT_668] = { let __args: [G; IN_668] = [__v_15, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[668].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_668] = unsafe { *(result.output.as_ptr() as *const [G; OUT_668]) }; __ret } else { aiur_fn_668(__args, record, io_buffer, __cu)? } };
+        let __v_44: G = __r_arr[0];
+        let __v_45: G = __r_arr[1];
+        let __v_46: G = __r_arr[2];
+        let __v_47: G = __r_arr[3];
+        let __v_48: G = __r_arr[4];
+        let __v_49: G = __r_arr[5];
+        let __v_50: G = __r_arr[6];
+        let __v_51: G = __r_arr[7];
+        let __v_52: G = __r_arr[8];
+        let __v_53: G = __r_arr[9];
+        let __r_arr: [G; OUT_668] = { let __args: [G; IN_668] = [__v_16, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[668].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_668] = unsafe { *(result.output.as_ptr() as *const [G; OUT_668]) }; __ret } else { aiur_fn_668(__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 __r_arr: [G; OUT_668] = { let __args: [G; IN_668] = [__v_17, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[668].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_668] = unsafe { *(result.output.as_ptr() as *const [G; OUT_668]) }; __ret } else { aiur_fn_668(__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 __v_68: G = __r_arr[4];
+        let __v_69: G = __r_arr[5];
+        let __v_70: G = __r_arr[6];
+        let __v_71: G = __r_arr[7];
+        let __v_72: G = __r_arr[8];
+        let __v_73: G = __r_arr[9];
+        let __r_arr: [G; OUT_668] = { let __args: [G; IN_668] = [__v_18, __v_73]; let __cu = unconstrained; if let Some(result) = record.function_queries[668].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_668] = unsafe { *(result.output.as_ptr() as *const [G; OUT_668]) }; __ret } else { aiur_fn_668(__args, record, io_buffer, __cu)? } };
+        let __v_74: G = __r_arr[0];
+        let __v_75: G = __r_arr[1];
+        let __v_76: G = __r_arr[2];
+        let __v_77: G = __r_arr[3];
+        let __v_78: G = __r_arr[4];
+        let __v_79: G = __r_arr[5];
+        let __v_80: G = __r_arr[6];
+        let __v_81: G = __r_arr[7];
+        let __v_82: G = __r_arr[8];
+        let __v_83: G = __r_arr[9];
+        let __r_arr: [G; OUT_669] = { let __args: [G; IN_669] = [__v_19, __v_83]; let __cu = unconstrained; if let Some(result) = record.function_queries[669].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_669] = unsafe { *(result.output.as_ptr() as *const [G; OUT_669]) }; __ret } else { aiur_fn_669(__args, record, io_buffer, __cu)? } };
+        let __v_84: G = __r_arr[0];
+        let __v_85: G = __r_arr[1];
+        let __v_86: G = __r_arr[2];
+        let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_20, __v_86]; let __cu = unconstrained; if let Some(result) = record.function_queries[674].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_674] = unsafe { *(result.output.as_ptr() as *const [G; OUT_674]) }; __ret } else { aiur_fn_674(__args, record, io_buffer, __cu)? } };
+        let __v_87: G = __r_arr[0];
+        let __v_88: G = __r_arr[1];
+        let __v_89: G = __r_arr[2];
+        let __v_90: G = G::from_u64(2);
+        let __ret: [G; OUT_679] = [__v_90, __v_28, __v_29, __v_31, __v_32, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_84, __v_85, __v_87, __v_88, __v_89];
+        record.function_queries[679].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -62527,1243 +55475,1435 @@ fn aiur_fn_746(
   })
 }
 
-const INPUT_SIZE_747: usize = 2;
-const IN_747: usize = 2;
-const OUT_747: usize = 0;
-fn aiur_fn_747(
-  inp: [G; IN_747],
+const INPUT_SIZE_680: usize = 1;
+const IN_680: usize = 1;
+const OUT_680: usize = 63;
+fn aiur_fn_680(
+  inp: [G; IN_680],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_680], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[70].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_70] = unsafe { *(result.output.as_ptr() as *const [G; OUT_70]) }; __ret } else { aiur_fn_70(__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_679] = { let __args: [G; IN_679] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[679].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_679] = unsafe { *(result.output.as_ptr() as *const [G; OUT_679]) }; __ret } else { aiur_fn_679(__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 = __r_arr[9];
+    let __v_20: G = __r_arr[10];
+    let __v_21: G = __r_arr[11];
+    let __v_22: G = __r_arr[12];
+    let __v_23: G = __r_arr[13];
+    let __v_24: G = __r_arr[14];
+    let __v_25: G = __r_arr[15];
+    let __v_26: G = __r_arr[16];
+    let __v_27: G = __r_arr[17];
+    let __v_28: G = __r_arr[18];
+    let __v_29: G = __r_arr[19];
+    let __v_30: G = __r_arr[20];
+    let __v_31: G = __r_arr[21];
+    let __v_32: G = __r_arr[22];
+    let __v_33: G = __r_arr[23];
+    let __v_34: G = __r_arr[24];
+    let __v_35: G = __r_arr[25];
+    let __v_36: G = __r_arr[26];
+    let __v_37: G = __r_arr[27];
+    let __v_38: G = __r_arr[28];
+    let __v_39: G = __r_arr[29];
+    let __v_40: G = __r_arr[30];
+    let __v_41: G = __r_arr[31];
+    let __v_42: G = __r_arr[32];
+    let __v_43: G = __r_arr[33];
+    let __v_44: G = __r_arr[34];
+    let __v_45: G = __r_arr[35];
+    let __v_46: G = __r_arr[36];
+    let __v_47: G = __r_arr[37];
+    let __v_48: G = __r_arr[38];
+    let __v_49: G = __r_arr[39];
+    let __v_50: G = __r_arr[40];
+    let __v_51: G = __r_arr[41];
+    let __v_52: G = __r_arr[42];
+    let __v_53: G = __r_arr[43];
+    let __v_54: G = __r_arr[44];
+    let __v_55: G = __r_arr[45];
+    let __v_56: G = __r_arr[46];
+    let __v_57: G = __r_arr[47];
+    let __v_58: G = __r_arr[48];
+    let __v_59: G = __r_arr[49];
+    let __v_60: G = __r_arr[50];
+    let __v_61: G = __r_arr[51];
+    let __v_62: G = __r_arr[52];
+    let __v_63: G = __r_arr[53];
+    let __v_64: G = __r_arr[54];
+    let __ret: [G; OUT_680] = [__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_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];
+    record.function_queries[680].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_681: usize = 9;
+const IN_681: usize = 9;
+const OUT_681: usize = 2;
+fn aiur_fn_681(
+  inp: [G; IN_681],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_747], ExecError> {
+) -> Result<[G; OUT_681], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 19] = { let __mq = record.memory_queries.get_mut(&19).ok_or(ExecError::InvalidMemorySize(19))?; 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: 19 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 19] = __args[..19].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];
-    let __v_12: G = __loaded[10];
-    let __v_13: G = __loaded[11];
-    let __v_14: G = __loaded[12];
-    let __v_15: G = __loaded[13];
-    let __v_16: G = __loaded[14];
-    let __v_17: G = __loaded[15];
-    let __v_18: G = __loaded[16];
-    let __v_19: G = __loaded[17];
-    let __v_20: G = __loaded[18];
-    match __v_2.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 __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__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[4].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } else { aiur_fn_4(__args, record, io_buffer, __cu)? } };
+    let __v_9: G = __r_arr[0];
+    match __v_9.as_canonical_u64() {
       1u64 => {
-        let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr };
-        let __v_21: G = __loaded[0];
-        let __v_22: G = __loaded[1];
-        let __v_23: G = __loaded[2];
-        let __v_24: G = __loaded[3];
-        let __v_25: G = __loaded[4];
-        let __v_26: G = __loaded[5];
-        let __v_27: G = __loaded[6];
-        let __v_28: G = __loaded[7];
-        let __v_29: G = __loaded[8];
-        let __v_30: G = __loaded[9];
-        let __v_31: G = __loaded[10];
-        match __v_21.as_canonical_u64() {
-          1u64 => {
-            let __ret: [G; OUT_747] = [];
-            record.function_queries[747].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_21.as_canonical_u64()));
-          },
-        }
-      },
-      0u64 => {
-        let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr };
-        let __v_21: G = __loaded[0];
-        let __v_22: G = __loaded[1];
-        let __v_23: G = __loaded[2];
-        let __v_24: G = __loaded[3];
-        let __v_25: G = __loaded[4];
-        let __v_26: G = __loaded[5];
-        let __v_27: G = __loaded[6];
-        let __v_28: G = __loaded[7];
-        let __v_29: G = __loaded[8];
-        let __v_30: G = __loaded[9];
-        let __v_31: G = __loaded[10];
-        match __v_21.as_canonical_u64() {
-          0u64 => {
-            match __v_3.as_canonical_u64() {
-              _ => {
-                match __v_22.as_canonical_u64() {
-                  _ => {
-                    let __v_32: G = G::from_u64(0);
-                    let __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_30, __v_32, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[746].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_746] = unsafe { *(result.output.as_ptr() as *const [G; OUT_746]) }; __ret } else { aiur_fn_746(__args, record, io_buffer, __cu)? } };
-                    if (__v_22 != __v_11) {
-                      return Err(ExecError::AssertEqMismatch { lhs: __v_22.as_canonical_u64(), rhs: __v_11.as_canonical_u64() });
-                    }
-                    if (__v_23 != __v_12) {
-                      return Err(ExecError::AssertEqMismatch { lhs: __v_23.as_canonical_u64(), rhs: __v_12.as_canonical_u64() });
-                    }
-                    if (__v_24 != __v_13) {
-                      return Err(ExecError::AssertEqMismatch { lhs: __v_24.as_canonical_u64(), rhs: __v_13.as_canonical_u64() });
-                    }
-                    if (__v_25 != __v_14) {
-                      return Err(ExecError::AssertEqMismatch { lhs: __v_25.as_canonical_u64(), rhs: __v_14.as_canonical_u64() });
-                    }
-                    if (__v_26 != __v_15) {
-                      return Err(ExecError::AssertEqMismatch { lhs: __v_26.as_canonical_u64(), rhs: __v_15.as_canonical_u64() });
-                    }
-                    if (__v_27 != __v_16) {
-                      return Err(ExecError::AssertEqMismatch { lhs: __v_27.as_canonical_u64(), rhs: __v_16.as_canonical_u64() });
-                    }
-                    if (__v_28 != __v_17) {
-                      return Err(ExecError::AssertEqMismatch { lhs: __v_28.as_canonical_u64(), rhs: __v_17.as_canonical_u64() });
-                    }
-                    if (__v_29 != __v_18) {
-                      return Err(ExecError::AssertEqMismatch { lhs: __v_29.as_canonical_u64(), rhs: __v_18.as_canonical_u64() });
-                    }
-                    let __r_arr: [G; OUT_747] = { let __args: [G; IN_747] = [__v_31, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[747].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_747] = unsafe { *(result.output.as_ptr() as *const [G; OUT_747]) }; __ret } else { aiur_fn_747(__args, record, io_buffer, __cu)? } };
-                    let __ret: [G; OUT_747] = [];
-                    record.function_queries[747].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                    return Ok(__ret);
-                  },
-                }
-              },
-            }
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_21.as_canonical_u64()));
-          },
-        }
+        let __v_10: G = G::from_u64(1);
+        let __v_11: G = G::from_u64(1);
+        let __v_12: G = { let __values: [G; 64] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&64).ok_or(ExecError::InvalidMemorySize(64))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_681] = [__v_12, __v_0];
+        record.function_queries[681].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+        let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = unsafe { *(result.output.as_ptr() as *const [G; OUT_680]) }; __ret } else { aiur_fn_680(__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 = __r_arr[9];
+        let __v_20: G = __r_arr[10];
+        let __v_21: G = __r_arr[11];
+        let __v_22: G = __r_arr[12];
+        let __v_23: G = __r_arr[13];
+        let __v_24: G = __r_arr[14];
+        let __v_25: G = __r_arr[15];
+        let __v_26: G = __r_arr[16];
+        let __v_27: G = __r_arr[17];
+        let __v_28: G = __r_arr[18];
+        let __v_29: G = __r_arr[19];
+        let __v_30: G = __r_arr[20];
+        let __v_31: G = __r_arr[21];
+        let __v_32: G = __r_arr[22];
+        let __v_33: G = __r_arr[23];
+        let __v_34: G = __r_arr[24];
+        let __v_35: G = __r_arr[25];
+        let __v_36: G = __r_arr[26];
+        let __v_37: G = __r_arr[27];
+        let __v_38: G = __r_arr[28];
+        let __v_39: G = __r_arr[29];
+        let __v_40: G = __r_arr[30];
+        let __v_41: G = __r_arr[31];
+        let __v_42: G = __r_arr[32];
+        let __v_43: G = __r_arr[33];
+        let __v_44: G = __r_arr[34];
+        let __v_45: G = __r_arr[35];
+        let __v_46: G = __r_arr[36];
+        let __v_47: G = __r_arr[37];
+        let __v_48: G = __r_arr[38];
+        let __v_49: G = __r_arr[39];
+        let __v_50: G = __r_arr[40];
+        let __v_51: G = __r_arr[41];
+        let __v_52: G = __r_arr[42];
+        let __v_53: G = __r_arr[43];
+        let __v_54: G = __r_arr[44];
+        let __v_55: G = __r_arr[45];
+        let __v_56: G = __r_arr[46];
+        let __v_57: G = __r_arr[47];
+        let __v_58: G = __r_arr[48];
+        let __v_59: G = __r_arr[49];
+        let __v_60: G = __r_arr[50];
+        let __v_61: G = __r_arr[51];
+        let __v_62: G = __r_arr[52];
+        let __v_63: G = __r_arr[53];
+        let __v_64: G = __r_arr[54];
+        let __v_65: G = __r_arr[55];
+        let __v_66: G = __r_arr[56];
+        let __v_67: G = __r_arr[57];
+        let __v_68: G = __r_arr[58];
+        let __v_69: G = __r_arr[59];
+        let __v_70: G = __r_arr[60];
+        let __v_71: G = __r_arr[61];
+        let __v_72: G = __r_arr[62];
+        let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__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[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } };
+        let __v_73: G = __r_arr[0];
+        let __v_74: G = __r_arr[1];
+        let __v_75: G = __r_arr[2];
+        let __v_76: G = __r_arr[3];
+        let __v_77: G = __r_arr[4];
+        let __v_78: G = __r_arr[5];
+        let __v_79: G = __r_arr[6];
+        let __v_80: G = __r_arr[7];
+        let __r_arr: [G; OUT_681] = { let __args: [G; IN_681] = [__v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80]; let __cu = unconstrained; if let Some(result) = record.function_queries[681].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_681] = unsafe { *(result.output.as_ptr() as *const [G; OUT_681]) }; __ret } else { aiur_fn_681(__args, record, io_buffer, __cu)? } };
+        let __v_81: G = __r_arr[0];
+        let __v_82: G = __r_arr[1];
+        let __v_83: G = G::from_u64(0);
+        let __v_84: G = { let __values: [G; 64] = [__v_83, __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_81]; let __mq = record.memory_queries.get_mut(&64).ok_or(ExecError::InvalidMemorySize(64))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_681] = [__v_84, __v_82];
+        record.function_queries[681].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_748: usize = 3;
-const IN_748: usize = 3;
-const OUT_748: usize = 0;
-fn aiur_fn_748(
-  inp: [G; IN_748],
+const INPUT_SIZE_682: usize = 1;
+const IN_682: usize = 1;
+const OUT_682: usize = 55;
+fn aiur_fn_682(
+  inp: [G; IN_682],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_748], ExecError> {
+) -> Result<[G; OUT_682], 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_68] = { let __args: [G; IN_68] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { 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_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[70].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_70] = unsafe { *(result.output.as_ptr() as *const [G; OUT_70]) }; __ret } else { aiur_fn_70(__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 __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_12: G = __b1_out[0];
+    let __v_13: G = __b1_out[1];
+    let __v_14: G = __b1_out[2];
+    let __v_15: G = __b1_out[3];
+    let __v_16: G = __b1_out[4];
+    let __v_17: G = __b1_out[5];
+    let __v_18: G = __b1_out[6];
+    let __v_19: 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_20: G = __b1_out[0];
+    let __v_21: G = __b1_out[1];
+    let __v_22: G = __b1_out[2];
+    let __v_23: G = __b1_out[3];
+    let __v_24: G = __b1_out[4];
+    let __v_25: G = __b1_out[5];
+    let __v_26: G = __b1_out[6];
+    let __v_27: G = __b1_out[7];
     match __v_1.as_canonical_u64() {
+      0u64 => {
+        let __r_arr: [G; OUT_671] = { let __args: [G; IN_671] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[671].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_671] = unsafe { *(result.output.as_ptr() as *const [G; OUT_671]) }; __ret } else { aiur_fn_671(__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 __r_arr: [G; OUT_671] = { let __args: [G; IN_671] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[671].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_671] = unsafe { *(result.output.as_ptr() as *const [G; OUT_671]) }; __ret } else { aiur_fn_671(__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 __r_arr: [G; OUT_668] = { let __args: [G; IN_668] = [__v_14, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[668].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_668] = unsafe { *(result.output.as_ptr() as *const [G; OUT_668]) }; __ret } else { aiur_fn_668(__args, record, io_buffer, __cu)? } };
+        let __v_34: G = __r_arr[0];
+        let __v_35: G = __r_arr[1];
+        let __v_36: G = __r_arr[2];
+        let __v_37: G = __r_arr[3];
+        let __v_38: G = __r_arr[4];
+        let __v_39: G = __r_arr[5];
+        let __v_40: G = __r_arr[6];
+        let __v_41: G = __r_arr[7];
+        let __v_42: G = __r_arr[8];
+        let __v_43: G = __r_arr[9];
+        let __r_arr: [G; OUT_669] = { let __args: [G; IN_669] = [__v_15, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[669].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_669] = unsafe { *(result.output.as_ptr() as *const [G; OUT_669]) }; __ret } else { aiur_fn_669(__args, record, io_buffer, __cu)? } };
+        let __v_44: G = __r_arr[0];
+        let __v_45: G = __r_arr[1];
+        let __v_46: G = __r_arr[2];
+        let __r_arr: [G; OUT_669] = { let __args: [G; IN_669] = [__v_16, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[669].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_669] = unsafe { *(result.output.as_ptr() as *const [G; OUT_669]) }; __ret } else { aiur_fn_669(__args, record, io_buffer, __cu)? } };
+        let __v_47: G = __r_arr[0];
+        let __v_48: G = __r_arr[1];
+        let __v_49: G = __r_arr[2];
+        let __v_50: G = G::from_u64(0);
+        let __v_51: G = G::from_u64(0);
+        let __ret: [G; OUT_682] = [__v_50, __v_28, __v_29, __v_31, __v_32, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_44, __v_45, __v_47, __v_48, __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, __v_51, __v_51, __v_51, __v_49];
+        record.function_queries[682].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
       1u64 => {
-        let __ret: [G; OUT_748] = [];
-        record.function_queries[748].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[670].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_670] = unsafe { *(result.output.as_ptr() as *const [G; OUT_670]) }; __ret } else { aiur_fn_670(__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 __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[670].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_670] = unsafe { *(result.output.as_ptr() as *const [G; OUT_670]) }; __ret } else { aiur_fn_670(__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 __r_arr: [G; OUT_668] = { let __args: [G; IN_668] = [__v_14, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[668].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_668] = unsafe { *(result.output.as_ptr() as *const [G; OUT_668]) }; __ret } else { aiur_fn_668(__args, record, io_buffer, __cu)? } };
+        let __v_34: G = __r_arr[0];
+        let __v_35: G = __r_arr[1];
+        let __v_36: G = __r_arr[2];
+        let __v_37: G = __r_arr[3];
+        let __v_38: G = __r_arr[4];
+        let __v_39: G = __r_arr[5];
+        let __v_40: G = __r_arr[6];
+        let __v_41: G = __r_arr[7];
+        let __v_42: G = __r_arr[8];
+        let __v_43: G = __r_arr[9];
+        let __r_arr: [G; OUT_668] = { let __args: [G; IN_668] = [__v_15, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[668].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_668] = unsafe { *(result.output.as_ptr() as *const [G; OUT_668]) }; __ret } else { aiur_fn_668(__args, record, io_buffer, __cu)? } };
+        let __v_44: G = __r_arr[0];
+        let __v_45: G = __r_arr[1];
+        let __v_46: G = __r_arr[2];
+        let __v_47: G = __r_arr[3];
+        let __v_48: G = __r_arr[4];
+        let __v_49: G = __r_arr[5];
+        let __v_50: G = __r_arr[6];
+        let __v_51: G = __r_arr[7];
+        let __v_52: G = __r_arr[8];
+        let __v_53: G = __r_arr[9];
+        let __r_arr: [G; OUT_668] = { let __args: [G; IN_668] = [__v_16, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[668].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_668] = unsafe { *(result.output.as_ptr() as *const [G; OUT_668]) }; __ret } else { aiur_fn_668(__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 __r_arr: [G; OUT_668] = { let __args: [G; IN_668] = [__v_17, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[668].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_668] = unsafe { *(result.output.as_ptr() as *const [G; OUT_668]) }; __ret } else { aiur_fn_668(__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 __v_68: G = __r_arr[4];
+        let __v_69: G = __r_arr[5];
+        let __v_70: G = __r_arr[6];
+        let __v_71: G = __r_arr[7];
+        let __v_72: G = __r_arr[8];
+        let __v_73: G = __r_arr[9];
+        let __r_arr: [G; OUT_668] = { let __args: [G; IN_668] = [__v_18, __v_73]; let __cu = unconstrained; if let Some(result) = record.function_queries[668].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_668] = unsafe { *(result.output.as_ptr() as *const [G; OUT_668]) }; __ret } else { aiur_fn_668(__args, record, io_buffer, __cu)? } };
+        let __v_74: G = __r_arr[0];
+        let __v_75: G = __r_arr[1];
+        let __v_76: G = __r_arr[2];
+        let __v_77: G = __r_arr[3];
+        let __v_78: G = __r_arr[4];
+        let __v_79: G = __r_arr[5];
+        let __v_80: G = __r_arr[6];
+        let __v_81: G = __r_arr[7];
+        let __v_82: G = __r_arr[8];
+        let __v_83: G = __r_arr[9];
+        let __r_arr: [G; OUT_669] = { let __args: [G; IN_669] = [__v_19, __v_83]; let __cu = unconstrained; if let Some(result) = record.function_queries[669].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_669] = unsafe { *(result.output.as_ptr() as *const [G; OUT_669]) }; __ret } else { aiur_fn_669(__args, record, io_buffer, __cu)? } };
+        let __v_84: G = __r_arr[0];
+        let __v_85: G = __r_arr[1];
+        let __v_86: G = __r_arr[2];
+        let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_20, __v_86]; let __cu = unconstrained; if let Some(result) = record.function_queries[674].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_674] = unsafe { *(result.output.as_ptr() as *const [G; OUT_674]) }; __ret } else { aiur_fn_674(__args, record, io_buffer, __cu)? } };
+        let __v_87: G = __r_arr[0];
+        let __v_88: G = __r_arr[1];
+        let __v_89: G = __r_arr[2];
+        let __v_90: G = G::from_u64(1);
+        let __ret: [G; OUT_682] = [__v_90, __v_28, __v_29, __v_31, __v_32, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_84, __v_85, __v_87, __v_88, __v_89];
+        record.function_queries[682].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      2u64 => {
+        let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[670].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_670] = unsafe { *(result.output.as_ptr() as *const [G; OUT_670]) }; __ret } else { aiur_fn_670(__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 __r_arr: [G; OUT_668] = { let __args: [G; IN_668] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[668].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_668] = unsafe { *(result.output.as_ptr() as *const [G; OUT_668]) }; __ret } else { aiur_fn_668(__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_669] = { let __args: [G; IN_669] = [__v_14, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[669].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_669] = unsafe { *(result.output.as_ptr() as *const [G; OUT_669]) }; __ret } else { aiur_fn_669(__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 = G::from_u64(2);
+        let __v_45: G = G::from_u64(0);
+        let __ret: [G; OUT_682] = [__v_44, __v_28, __v_29, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_41, __v_42, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_43];
+        record.function_queries[682].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      3u64 => {
+        let __r_arr: [G; OUT_672] = { let __args: [G; IN_672] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[672].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_672] = unsafe { *(result.output.as_ptr() as *const [G; OUT_672]) }; __ret } else { aiur_fn_672(__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 __r_arr: [G; OUT_668] = { let __args: [G; IN_668] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[668].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_668] = unsafe { *(result.output.as_ptr() as *const [G; OUT_668]) }; __ret } else { aiur_fn_668(__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_669] = { let __args: [G; IN_669] = [__v_14, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[669].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_669] = unsafe { *(result.output.as_ptr() as *const [G; OUT_669]) }; __ret } else { aiur_fn_669(__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 = G::from_u64(3);
+        let __v_45: G = G::from_u64(0);
+        let __ret: [G; OUT_682] = [__v_44, __v_28, __v_29, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_41, __v_42, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_43];
+        record.function_queries[682].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      4u64 => {
+        let __r_arr: [G; OUT_668] = { let __args: [G; IN_668] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[668].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_668] = unsafe { *(result.output.as_ptr() as *const [G; OUT_668]) }; __ret } else { aiur_fn_668(__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 __r_arr: [G; OUT_668] = { let __args: [G; IN_668] = [__v_13, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[668].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_668] = unsafe { *(result.output.as_ptr() as *const [G; OUT_668]) }; __ret } else { aiur_fn_668(__args, record, io_buffer, __cu)? } };
+        let __v_38: G = __r_arr[0];
+        let __v_39: G = __r_arr[1];
+        let __v_40: G = __r_arr[2];
+        let __v_41: G = __r_arr[3];
+        let __v_42: G = __r_arr[4];
+        let __v_43: G = __r_arr[5];
+        let __v_44: G = __r_arr[6];
+        let __v_45: G = __r_arr[7];
+        let __v_46: G = __r_arr[8];
+        let __v_47: G = __r_arr[9];
+        let __r_arr: [G; OUT_669] = { let __args: [G; IN_669] = [__v_14, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[669].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_669] = unsafe { *(result.output.as_ptr() as *const [G; OUT_669]) }; __ret } else { aiur_fn_669(__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];
+        let __v_51: G = G::from_u64(4);
+        let __v_52: G = G::from_u64(0);
+        let __ret: [G; OUT_682] = [__v_51, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_48, __v_49, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_50];
+        record.function_queries[682].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      5u64 => {
+        let __r_arr: [G; OUT_668] = { let __args: [G; IN_668] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[668].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_668] = unsafe { *(result.output.as_ptr() as *const [G; OUT_668]) }; __ret } else { aiur_fn_668(__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 __r_arr: [G; OUT_669] = { let __args: [G; IN_669] = [__v_13, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[669].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_669] = unsafe { *(result.output.as_ptr() as *const [G; OUT_669]) }; __ret } else { aiur_fn_669(__args, record, io_buffer, __cu)? } };
+        let __v_38: G = __r_arr[0];
+        let __v_39: G = __r_arr[1];
+        let __v_40: G = __r_arr[2];
+        let __v_41: G = G::from_u64(5);
+        let __v_42: G = G::from_u64(0);
+        let __ret: [G; OUT_682] = [__v_41, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_39, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_40];
+        record.function_queries[682].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __r_arr: [G; OUT_747] = { let __args: [G; IN_747] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[747].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_747] = unsafe { *(result.output.as_ptr() as *const [G; OUT_747]) }; __ret } else { aiur_fn_747(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_748] = [];
-        record.function_queries[748].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+      6u64 => {
+        let __r_arr: [G; OUT_668] = { let __args: [G; IN_668] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[668].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_668] = unsafe { *(result.output.as_ptr() as *const [G; OUT_668]) }; __ret } else { aiur_fn_668(__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 __r_arr: [G; OUT_669] = { let __args: [G; IN_669] = [__v_13, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[669].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_669] = unsafe { *(result.output.as_ptr() as *const [G; OUT_669]) }; __ret } else { aiur_fn_669(__args, record, io_buffer, __cu)? } };
+        let __v_38: G = __r_arr[0];
+        let __v_39: G = __r_arr[1];
+        let __v_40: G = __r_arr[2];
+        let __v_41: G = G::from_u64(6);
+        let __v_42: G = G::from_u64(0);
+        let __ret: [G; OUT_682] = [__v_41, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_39, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_40];
+        record.function_queries[682].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_749: usize = 49;
-const IN_749: usize = 49;
-const OUT_749: usize = 0;
-fn aiur_fn_749(
-  inp: [G; IN_749],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_749], 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 __r_arr: [G; OUT_788] = { let __args: [G; IN_788] = [__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[788].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_788] = unsafe { *(result.output.as_ptr() as *const [G; OUT_788]) }; __ret } else { aiur_fn_788(__args, record, io_buffer, __cu)? } };
-    let __v_49: G = __r_arr[0];
-    let __v_50: G = __r_arr[1];
-    let __v_51: G = __r_arr[2];
-    let __v_52: G = __r_arr[3];
-    let __v_53: G = __r_arr[4];
-    let __v_54: G = __r_arr[5];
-    let __v_55: G = __r_arr[6];
-    let __v_56: G = __r_arr[7];
-    let __v_57: G = __r_arr[8];
-    let __v_58: G = __r_arr[9];
-    let __v_59: G = __r_arr[10];
-    let __v_60: G = __r_arr[11];
-    let __v_61: G = __r_arr[12];
-    let __v_62: G = __r_arr[13];
-    let __v_63: G = __r_arr[14];
-    let __v_64: G = __r_arr[15];
-    let __v_65: G = __r_arr[16];
-    let __v_66: G = __r_arr[17];
-    let __v_67: G = __r_arr[18];
-    let __v_68: G = __r_arr[19];
-    let __v_69: G = __r_arr[20];
-    let __v_70: G = __r_arr[21];
-    let __v_71: G = __r_arr[22];
-    let __v_72: G = __r_arr[23];
-    let __v_73: G = __r_arr[24];
-    let __v_74: G = __r_arr[25];
-    let __v_75: G = __r_arr[26];
-    let __v_76: G = __r_arr[27];
-    let __v_77: G = __r_arr[28];
-    let __v_78: G = __r_arr[29];
-    let __v_79: G = __r_arr[30];
-    let __v_80: G = __r_arr[31];
-    let __v_81: G = __r_arr[32];
-    let __v_82: G = __r_arr[33];
-    match __v_9.as_canonical_u64() {
-      _ => {
-        match __v_49.as_canonical_u64() {
-          _ => {
-            let __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__v_49, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } else { aiur_fn_743(__args, record, io_buffer, __cu)? } };
-            let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_11, __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[744].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } else { aiur_fn_744(__args, record, io_buffer, __cu)? } };
-            let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } else { aiur_fn_744(__args, record, io_buffer, __cu)? } };
-            let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __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[744].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } else { aiur_fn_744(__args, record, io_buffer, __cu)? } };
-            let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } else { aiur_fn_744(__args, record, io_buffer, __cu)? } };
-            let __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_82, __v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[746].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_746] = unsafe { *(result.output.as_ptr() as *const [G; OUT_746]) }; __ret } else { aiur_fn_746(__args, record, io_buffer, __cu)? } };
-            let __ret: [G; OUT_749] = [];
-            record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-        }
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_750: usize = 2;
-const IN_750: usize = 2;
-const OUT_750: usize = 0;
-fn aiur_fn_750(
-  inp: [G; IN_750],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_750], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __loaded: [G; 50] = { let __mq = record.memory_queries.get_mut(&50).ok_or(ExecError::InvalidMemorySize(50))?; 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: 50 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 50] = __args[..50].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];
-    let __v_12: G = __loaded[10];
-    let __v_13: G = __loaded[11];
-    let __v_14: G = __loaded[12];
-    let __v_15: G = __loaded[13];
-    let __v_16: G = __loaded[14];
-    let __v_17: G = __loaded[15];
-    let __v_18: G = __loaded[16];
-    let __v_19: G = __loaded[17];
-    let __v_20: G = __loaded[18];
-    let __v_21: G = __loaded[19];
-    let __v_22: G = __loaded[20];
-    let __v_23: G = __loaded[21];
-    let __v_24: G = __loaded[22];
-    let __v_25: G = __loaded[23];
-    let __v_26: G = __loaded[24];
-    let __v_27: G = __loaded[25];
-    let __v_28: G = __loaded[26];
-    let __v_29: G = __loaded[27];
-    let __v_30: G = __loaded[28];
-    let __v_31: G = __loaded[29];
-    let __v_32: G = __loaded[30];
-    let __v_33: G = __loaded[31];
-    let __v_34: G = __loaded[32];
-    let __v_35: G = __loaded[33];
-    let __v_36: G = __loaded[34];
-    let __v_37: G = __loaded[35];
-    let __v_38: G = __loaded[36];
-    let __v_39: G = __loaded[37];
-    let __v_40: G = __loaded[38];
-    let __v_41: G = __loaded[39];
-    let __v_42: G = __loaded[40];
-    let __v_43: G = __loaded[41];
-    let __v_44: G = __loaded[42];
-    let __v_45: G = __loaded[43];
-    let __v_46: G = __loaded[44];
-    let __v_47: G = __loaded[45];
-    let __v_48: G = __loaded[46];
-    let __v_49: G = __loaded[47];
-    let __v_50: G = __loaded[48];
-    let __v_51: G = __loaded[49];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
-        let __ret: [G; OUT_750] = [];
-        record.function_queries[750].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+      7u64 => {
+        let __r_arr: [G; OUT_668] = { let __args: [G; IN_668] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[668].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_668] = unsafe { *(result.output.as_ptr() as *const [G; OUT_668]) }; __ret } else { aiur_fn_668(__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 __r_arr: [G; OUT_669] = { let __args: [G; IN_669] = [__v_13, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[669].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_669] = unsafe { *(result.output.as_ptr() as *const [G; OUT_669]) }; __ret } else { aiur_fn_669(__args, record, io_buffer, __cu)? } };
+        let __v_38: G = __r_arr[0];
+        let __v_39: G = __r_arr[1];
+        let __v_40: G = __r_arr[2];
+        let __v_41: G = G::from_u64(7);
+        let __v_42: G = G::from_u64(0);
+        let __ret: [G; OUT_682] = [__v_41, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_39, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_40];
+        record.function_queries[682].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      0u64 => {
-        let __r_arr: [G; OUT_749] = { let __args: [G; IN_749] = [__v_0, __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_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]; let __cu = unconstrained; if let Some(result) = record.function_queries[749].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_749] = unsafe { *(result.output.as_ptr() as *const [G; OUT_749]) }; __ret } else { aiur_fn_749(__args, record, io_buffer, __cu)? } };
-        let __r_arr: [G; OUT_750] = { let __args: [G; IN_750] = [__v_0, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[750].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_750] = unsafe { *(result.output.as_ptr() as *const [G; OUT_750]) }; __ret } else { aiur_fn_750(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_750] = [];
-        record.function_queries[750].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+      8u64 => {
+        let __mc_out___mc_0: [G; 2] = '__mc_0: { match __v_12.as_canonical_u64() {
+  0u64 => {
+    let __v_28: G = G::from_u64(1);
+    let __v_29: G = G::from_u64(1);
+    let __v_30: G = { let __values: [G; 64] = [__v_28, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29]; let __mq = record.memory_queries.get_mut(&64).ok_or(ExecError::InvalidMemorySize(64))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    break '__mc_0 [__v_30, __v_11];
+  },
+  1u64 => {
+    let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[70].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_70] = unsafe { *(result.output.as_ptr() as *const [G; OUT_70]) }; __ret } else { aiur_fn_70(__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 __r_arr: [G; OUT_681] = { let __args: [G; IN_681] = [__v_36, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[681].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_681] = unsafe { *(result.output.as_ptr() as *const [G; OUT_681]) }; __ret } else { aiur_fn_681(__args, record, io_buffer, __cu)? } };
+    let __v_37: G = __r_arr[0];
+    let __v_38: G = __r_arr[1];
+    break '__mc_0 [__v_37, __v_38];
+  },
+  _ => {
+    return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64()));
+  },
+}
+ };
+        let __v_28: G = __mc_out___mc_0[0];
+        let __v_29: G = __mc_out___mc_0[1];
+        let __v_30: G = G::from_u64(8);
+        let __v_31: G = G::from_u64(0);
+        let __ret: [G; OUT_682] = [__v_30, __v_28, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_29];
+        record.function_queries[682].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_751: usize = 3;
-const IN_751: usize = 3;
-const OUT_751: usize = 0;
-fn aiur_fn_751(
-  inp: [G; IN_751],
+const INPUT_SIZE_683: usize = 1;
+const IN_683: usize = 1;
+const OUT_683: usize = 1;
+fn aiur_fn_683(
+  inp: [G; IN_683],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_751], ExecError> {
+) -> Result<[G; OUT_683], 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_1.as_canonical_u64() {
-      1u64 => {
-        let __ret: [G; OUT_751] = [];
-        record.function_queries[751].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __r_arr: [G; OUT_750] = { let __args: [G; IN_750] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[750].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_750] = unsafe { *(result.output.as_ptr() as *const [G; OUT_750]) }; __ret } else { aiur_fn_750(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_751] = [];
-        record.function_queries[751].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
-      },
-    }
+    let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; 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: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].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 = G::from_u64(1);
+    let __v_20: G = G::from_u64(1);
+    let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __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 __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__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_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } else { aiur_fn_29(__args, record, io_buffer, __cu)? } };
+    let __v_22: G = __r_arr[0];
+    let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[18].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_18] = unsafe { *(result.output.as_ptr() as *const [G; OUT_18]) }; __ret } else { aiur_fn_18(__args, record, io_buffer, __cu)? } };
+    let __v_23: G = __r_arr[0];
+    let __ret: [G; OUT_683] = [__v_23];
+    record.function_queries[683].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_752: usize = 99;
-const IN_752: usize = 99;
-const OUT_752: usize = 0;
-fn aiur_fn_752(
-  inp: [G; IN_752],
+const INPUT_SIZE_684: usize = 1;
+const IN_684: usize = 1;
+const OUT_684: usize = 1;
+fn aiur_fn_684(
+  inp: [G; IN_684],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_752], ExecError> {
+) -> Result<[G; OUT_684], 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];
     match __v_0.as_canonical_u64() {
       0u64 => {
-        match __v_45.as_canonical_u64() {
-          0u64 => {
-            match __v_1.as_canonical_u64() {
-              _ => {
-                let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_1, __v_46, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } else { aiur_fn_741(__args, record, io_buffer, __cu)? } };
-                let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_2, __v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } else { aiur_fn_741(__args, record, io_buffer, __cu)? } };
-                let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } else { aiur_fn_744(__args, record, io_buffer, __cu)? } };
-                let __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_11, __v_59, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[746].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_746] = unsafe { *(result.output.as_ptr() as *const [G; OUT_746]) }; __ret } else { aiur_fn_746(__args, record, io_buffer, __cu)? } };
-                let __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_12, __v_61, __v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[746].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_746] = unsafe { *(result.output.as_ptr() as *const [G; OUT_746]) }; __ret } else { aiur_fn_746(__args, record, io_buffer, __cu)? } };
-                let __ret: [G; OUT_752] = [];
-                record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-            }
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_45.as_canonical_u64()));
-          },
-        }
+        let __v_1: G = G::from_u64(0);
+        let __ret: [G; OUT_684] = [__v_1];
+        record.function_queries[684].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
       1u64 => {
-        match __v_45.as_canonical_u64() {
-          1u64 => {
-            match __v_1.as_canonical_u64() {
-              _ => {
-                let __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__v_1, __v_46, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } else { aiur_fn_743(__args, record, io_buffer, __cu)? } };
-                let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } else { aiur_fn_744(__args, record, io_buffer, __cu)? } };
-                let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } else { aiur_fn_744(__args, record, io_buffer, __cu)? } };
-                let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } else { aiur_fn_744(__args, record, io_buffer, __cu)? } };
-                let __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_26, __v_75, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[746].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_746] = unsafe { *(result.output.as_ptr() as *const [G; OUT_746]) }; __ret } else { aiur_fn_746(__args, record, io_buffer, __cu)? } };
-                let __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_27, __v_77, __v_78]; let __cu = unconstrained; if let Some(result) = record.function_queries[751].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_751] = unsafe { *(result.output.as_ptr() as *const [G; OUT_751]) }; __ret } else { aiur_fn_751(__args, record, io_buffer, __cu)? } };
-                let __ret: [G; OUT_752] = [];
-                record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-            }
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_45.as_canonical_u64()));
-          },
-        }
+        let __v_1: G = G::from_u64(1);
+        let __ret: [G; OUT_684] = [__v_1];
+        record.function_queries[684].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
       2u64 => {
-        match __v_45.as_canonical_u64() {
-          2u64 => {
-            match __v_1.as_canonical_u64() {
-              _ => {
-                let __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__v_1, __v_46, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } else { aiur_fn_743(__args, record, io_buffer, __cu)? } };
-                let __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__v_2, __v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } else { aiur_fn_743(__args, record, io_buffer, __cu)? } };
-                let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } else { aiur_fn_744(__args, record, io_buffer, __cu)? } };
-                let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } else { aiur_fn_744(__args, record, io_buffer, __cu)? } };
-                let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } else { aiur_fn_744(__args, record, io_buffer, __cu)? } };
-                let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } else { aiur_fn_744(__args, record, io_buffer, __cu)? } };
-                let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } else { aiur_fn_744(__args, record, io_buffer, __cu)? } };
-                let __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_43, __v_95, __v_96]; let __cu = unconstrained; if let Some(result) = record.function_queries[746].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_746] = unsafe { *(result.output.as_ptr() as *const [G; OUT_746]) }; __ret } else { aiur_fn_746(__args, record, io_buffer, __cu)? } };
-                let __r_arr: [G; OUT_748] = { let __args: [G; IN_748] = [__v_44, __v_97, __v_98]; let __cu = unconstrained; if let Some(result) = record.function_queries[748].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_748] = unsafe { *(result.output.as_ptr() as *const [G; OUT_748]) }; __ret } else { aiur_fn_748(__args, record, io_buffer, __cu)? } };
-                let __ret: [G; OUT_752] = [];
-                record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-            }
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_45.as_canonical_u64()));
-          },
-        }
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64()));
+        let __v_1: G = G::from_u64(2);
+        let __ret: [G; OUT_684] = [__v_1];
+        record.function_queries[684].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
-    }
-  })
-}
-
-const INPUT_SIZE_753: usize = 2;
-const IN_753: usize = 2;
-const OUT_753: usize = 0;
-fn aiur_fn_753(
-  inp: [G; IN_753],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_753], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __loaded: [G; 64] = { let __mq = record.memory_queries.get_mut(&64).ok_or(ExecError::InvalidMemorySize(64))?; 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: 64 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 64] = __args[..64].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];
-    let __v_12: G = __loaded[10];
-    let __v_13: G = __loaded[11];
-    let __v_14: G = __loaded[12];
-    let __v_15: G = __loaded[13];
-    let __v_16: G = __loaded[14];
-    let __v_17: G = __loaded[15];
-    let __v_18: G = __loaded[16];
-    let __v_19: G = __loaded[17];
-    let __v_20: G = __loaded[18];
-    let __v_21: G = __loaded[19];
-    let __v_22: G = __loaded[20];
-    let __v_23: G = __loaded[21];
-    let __v_24: G = __loaded[22];
-    let __v_25: G = __loaded[23];
-    let __v_26: G = __loaded[24];
-    let __v_27: G = __loaded[25];
-    let __v_28: G = __loaded[26];
-    let __v_29: G = __loaded[27];
-    let __v_30: G = __loaded[28];
-    let __v_31: G = __loaded[29];
-    let __v_32: G = __loaded[30];
-    let __v_33: G = __loaded[31];
-    let __v_34: G = __loaded[32];
-    let __v_35: G = __loaded[33];
-    let __v_36: G = __loaded[34];
-    let __v_37: G = __loaded[35];
-    let __v_38: G = __loaded[36];
-    let __v_39: G = __loaded[37];
-    let __v_40: G = __loaded[38];
-    let __v_41: G = __loaded[39];
-    let __v_42: G = __loaded[40];
-    let __v_43: G = __loaded[41];
-    let __v_44: G = __loaded[42];
-    let __v_45: G = __loaded[43];
-    let __v_46: G = __loaded[44];
-    let __v_47: G = __loaded[45];
-    let __v_48: G = __loaded[46];
-    let __v_49: G = __loaded[47];
-    let __v_50: G = __loaded[48];
-    let __v_51: G = __loaded[49];
-    let __v_52: G = __loaded[50];
-    let __v_53: G = __loaded[51];
-    let __v_54: G = __loaded[52];
-    let __v_55: G = __loaded[53];
-    let __v_56: G = __loaded[54];
-    let __v_57: G = __loaded[55];
-    let __v_58: G = __loaded[56];
-    let __v_59: G = __loaded[57];
-    let __v_60: G = __loaded[58];
-    let __v_61: G = __loaded[59];
-    let __v_62: G = __loaded[60];
-    let __v_63: G = __loaded[61];
-    let __v_64: G = __loaded[62];
-    let __v_65: G = __loaded[63];
-    match __v_2.as_canonical_u64() {
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_685: usize = 3;
+const IN_685: usize = 3;
+const OUT_685: usize = 0;
+fn aiur_fn_685(
+  inp: [G; IN_685],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_685], 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_1.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_753] = [];
-        record.function_queries[753].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_685] = [];
+        record.function_queries[685].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_0, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[782].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_782] = unsafe { *(result.output.as_ptr() as *const [G; OUT_782]) }; __ret } else { aiur_fn_782(__args, record, io_buffer, __cu)? } };
-        let __v_66: G = __r_arr[0];
-        let __v_67: G = __r_arr[1];
-        let __v_68: G = __r_arr[2];
-        let __v_69: G = __r_arr[3];
-        let __v_70: G = __r_arr[4];
-        let __v_71: G = __r_arr[5];
-        let __v_72: G = __r_arr[6];
-        let __v_73: G = __r_arr[7];
-        let __v_74: G = __r_arr[8];
-        let __v_75: G = __r_arr[9];
-        let __v_76: G = __r_arr[10];
-        let __v_77: G = __r_arr[11];
-        let __v_78: G = __r_arr[12];
-        let __v_79: G = __r_arr[13];
-        let __v_80: G = __r_arr[14];
-        let __v_81: G = __r_arr[15];
-        let __v_82: G = __r_arr[16];
-        let __v_83: G = __r_arr[17];
-        let __v_84: G = __r_arr[18];
-        let __v_85: G = __r_arr[19];
-        let __v_86: G = __r_arr[20];
-        let __v_87: G = __r_arr[21];
-        let __v_88: G = __r_arr[22];
-        let __v_89: G = __r_arr[23];
-        let __v_90: G = __r_arr[24];
-        let __v_91: G = __r_arr[25];
-        let __v_92: G = __r_arr[26];
-        let __v_93: G = __r_arr[27];
-        let __v_94: G = __r_arr[28];
-        let __v_95: G = __r_arr[29];
-        let __v_96: G = __r_arr[30];
-        let __v_97: G = __r_arr[31];
-        let __v_98: G = __r_arr[32];
-        let __v_99: G = __r_arr[33];
-        let __v_100: G = __r_arr[34];
-        let __v_101: G = __r_arr[35];
-        let __v_102: G = __r_arr[36];
-        let __v_103: G = __r_arr[37];
-        let __v_104: G = __r_arr[38];
-        let __v_105: G = __r_arr[39];
-        let __v_106: G = __r_arr[40];
-        let __v_107: G = __r_arr[41];
-        let __v_108: G = __r_arr[42];
-        let __v_109: G = __r_arr[43];
-        let __v_110: G = __r_arr[44];
-        let __r_arr: [G; OUT_752] = { let __args: [G; IN_752] = [__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_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]; let __cu = unconstrained; if let Some(result) = record.function_queries[752].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_752] = unsafe { *(result.output.as_ptr() as *const [G; OUT_752]) }; __ret } else { aiur_fn_752(__args, record, io_buffer, __cu)? } };
-        let __r_arr: [G; OUT_753] = { let __args: [G; IN_753] = [__v_0, __v_65]; let __cu = unconstrained; if let Some(result) = record.function_queries[753].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_753] = unsafe { *(result.output.as_ptr() as *const [G; OUT_753]) }; __ret } else { aiur_fn_753(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_753] = [];
-        record.function_queries[753].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_684] = { let __args: [G; IN_684] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[684].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_684] = unsafe { *(result.output.as_ptr() as *const [G; OUT_684]) }; __ret } else { aiur_fn_684(__args, record, io_buffer, __cu)? } };
+        let __v_3: G = __r_arr[0];
+        let __r_arr: [G; OUT_684] = { let __args: [G; IN_684] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[684].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_684] = unsafe { *(result.output.as_ptr() as *const [G; OUT_684]) }; __ret } else { aiur_fn_684(__args, record, io_buffer, __cu)? } };
+        let __v_4: G = __r_arr[0];
+        if (__v_3 != __v_4) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("Reveal: claimed definition kind != real".to_string()) });
+        }
+        let __ret: [G; OUT_685] = [];
+        record.function_queries[685].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_754: usize = 1;
-const IN_754: usize = 1;
-const OUT_754: usize = 1;
-fn aiur_fn_754(
-  inp: [G; IN_754],
+const INPUT_SIZE_686: usize = 3;
+const IN_686: usize = 3;
+const OUT_686: usize = 0;
+fn aiur_fn_686(
+  inp: [G; IN_686],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_754], ExecError> {
+) -> Result<[G; OUT_686], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __v_1: G = G::from_u64(1);
-    let __v_2: G = G::from_u64(1);
-    let __v_3: G = { let __values: [G; 3] = [__v_1, __v_2, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_39] = { let __args: [G; IN_39] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[39].get_mut(&__args[..]) { 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 = G::from_u64(0);
-    let __v_6: G = G::from_u64(0);
-    let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __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 __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } else { aiur_fn_16(__args, record, io_buffer, __cu)? } };
-    let __v_8: G = __r_arr[0];
-    let __ret: [G; OUT_754] = [__v_8];
-    record.function_queries[754].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    match __v_1.as_canonical_u64() {
+      1u64 => {
+        let __ret: [G; OUT_686] = [];
+        record.function_queries[686].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __r_arr: [G; OUT_684] = { let __args: [G; IN_684] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[684].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_684] = unsafe { *(result.output.as_ptr() as *const [G; OUT_684]) }; __ret } else { aiur_fn_684(__args, record, io_buffer, __cu)? } };
+        let __v_3: G = __r_arr[0];
+        let __r_arr: [G; OUT_684] = { let __args: [G; IN_684] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[684].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_684] = unsafe { *(result.output.as_ptr() as *const [G; OUT_684]) }; __ret } else { aiur_fn_684(__args, record, io_buffer, __cu)? } };
+        let __v_4: G = __r_arr[0];
+        if (__v_3 != __v_4) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("Reveal: claimed definition safety != real".to_string()) });
+        }
+        let __ret: [G; OUT_686] = [];
+        record.function_queries[686].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+      },
+    }
   })
 }
 
-const INPUT_SIZE_755: usize = 2;
-const IN_755: usize = 2;
-const OUT_755: usize = 1;
-fn aiur_fn_755(
-  inp: [G; IN_755],
+const INPUT_SIZE_687: usize = 3;
+const IN_687: usize = 3;
+const OUT_687: usize = 0;
+fn aiur_fn_687(
+  inp: [G; IN_687],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_755], ExecError> {
+) -> Result<[G; OUT_687], 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_39] = { let __args: [G; IN_39] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[39].get_mut(&__args[..]) { 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_5: G = __r_arr[0];
-    let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[39].get_mut(&__args[..]) { 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 = G::from_u64(0);
-    let __v_8: G = G::from_u64(1);
-    let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __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 __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } else { aiur_fn_16(__args, record, io_buffer, __cu)? } };
-    let __v_10: G = __r_arr[0];
-    let __ret: [G; OUT_755] = [__v_10];
-    record.function_queries[755].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
+    let __v_2: G = inp[2];
+    match __v_1.as_canonical_u64() {
+      1u64 => {
+        let __ret: [G; OUT_687] = [];
+        record.function_queries[687].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[94].get_mut(&__args[..]) { 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_3: G = __r_arr[0];
+        let __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[94].get_mut(&__args[..]) { 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_4: G = __r_arr[0];
+        if (__v_3 != __v_4) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("Reveal: claimed quotient kind != real".to_string()) });
+        }
+        let __ret: [G; OUT_687] = [];
+        record.function_queries[687].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+      },
+    }
   })
 }
 
-const INPUT_SIZE_756: usize = 1;
-const IN_756: usize = 1;
-const OUT_756: usize = 3;
-fn aiur_fn_756(
-  inp: [G; IN_756],
+const INPUT_SIZE_688: usize = 3;
+const IN_688: usize = 3;
+const OUT_688: usize = 0;
+fn aiur_fn_688(
+  inp: [G; IN_688],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_756], ExecError> {
+) -> Result<[G; OUT_688], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[66].get_mut(&__args[..]) { 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_1: G = __r_arr[0];
-    let __v_2: G = __r_arr[1];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
     match __v_1.as_canonical_u64() {
+      1u64 => {
+        let __ret: [G; OUT_688] = [];
+        record.function_queries[688].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
       0u64 => {
-        let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[79].get_mut(&__args[..]) { 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_3: G = __r_arr[0];
-        let __v_4: G = __r_arr[1];
-        let __r_arr: [G; OUT_754] = { let __args: [G; IN_754] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[754].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_754] = unsafe { *(result.output.as_ptr() as *const [G; OUT_754]) }; __ret } else { aiur_fn_754(__args, record, io_buffer, __cu)? } };
-        let __v_5: G = __r_arr[0];
-        let __v_6: G = G::from_u64(0);
-        let __v_7: G = G::from_u64(1);
-        let __v_8: G = G::from_u64(1);
-        let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __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_10: G = { let __values: [G; 3] = [__v_6, __v_3, __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 __ret: [G; OUT_756] = [__v_5, __v_10, __v_4];
-        record.function_queries[756].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        if (__v_0 != __v_2) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_0.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("Reveal: claimed flag != real".to_string()) });
+        }
+        let __ret: [G; OUT_688] = [];
+        record.function_queries[688].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_689: usize = 17;
+const IN_689: usize = 17;
+const OUT_689: usize = 0;
+fn aiur_fn_689(
+  inp: [G; IN_689],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_689], 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];
+    match __v_8.as_canonical_u64() {
       1u64 => {
-        let __v_3: G = G::from_u64(0);
-        let __v_4: G = G::from_u64(0);
-        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 __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 = 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 __v_24: G = G::from_u64(0);
-        let __v_25: G = G::from_u64(0);
-        let __v_26: G = G::from_u64(0);
-        let __v_27: G = G::from_u64(0);
-        let __v_28: G = G::from_u64(0);
-        let __v_29: G = G::from_u64(0);
-        let __v_30: G = G::from_u64(0);
-        let __v_31: G = G::from_u64(0);
-        let __v_32: G = G::from_u64(0);
-        let __v_33: G = G::from_u64(0);
-        let __v_34: G = G::from_u64(0);
-        let __v_35: G = { let __values: [G; 32] = [__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]; 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_36: G = G::from_u64(1);
-        let __v_37: G = G::from_u64(1);
-        let __v_38: G = { let __values: [G; 3] = [__v_36, __v_37, __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 __ret: [G; OUT_756] = [__v_35, __v_38, __v_2];
-        record.function_queries[756].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_689] = [];
+        record.function_queries[689].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      2u64 => {
-        let __r_arr: [G; OUT_756] = { let __args: [G; IN_756] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[756].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_756] = unsafe { *(result.output.as_ptr() as *const [G; OUT_756]) }; __ret } else { aiur_fn_756(__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 __r_arr: [G; OUT_756] = { let __args: [G; IN_756] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[756].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_756] = unsafe { *(result.output.as_ptr() as *const [G; OUT_756]) }; __ret } else { aiur_fn_756(__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 __r_arr: [G; OUT_755] = { let __args: [G; IN_755] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[755].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_755] = unsafe { *(result.output.as_ptr() as *const [G; OUT_755]) }; __ret } else { aiur_fn_755(__args, record, io_buffer, __cu)? } };
-        let __v_9: G = __r_arr[0];
-        let __r_arr: [G; OUT_773] = { let __args: [G; IN_773] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[773].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_773] = unsafe { *(result.output.as_ptr() as *const [G; OUT_773]) }; __ret } else { aiur_fn_773(__args, record, io_buffer, __cu)? } };
-        let __v_10: G = __r_arr[0];
-        let __ret: [G; OUT_756] = [__v_9, __v_10, __v_8];
-        record.function_queries[756].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+      0u64 => {
+        if (__v_0 != __v_9) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_0.as_canonical_u64(), rhs: __v_9.as_canonical_u64(), msg: Some("Reveal: claimed numeric field != real".to_string()) });
+        }
+        if (__v_1 != __v_10) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_1.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: Some("Reveal: claimed numeric field != real".to_string()) });
+        }
+        if (__v_2 != __v_11) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_2.as_canonical_u64(), rhs: __v_11.as_canonical_u64(), msg: Some("Reveal: claimed numeric field != real".to_string()) });
+        }
+        if (__v_3 != __v_12) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: Some("Reveal: claimed numeric field != real".to_string()) });
+        }
+        if (__v_4 != __v_13) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_4.as_canonical_u64(), rhs: __v_13.as_canonical_u64(), msg: Some("Reveal: claimed numeric field != real".to_string()) });
+        }
+        if (__v_5 != __v_14) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: Some("Reveal: claimed numeric field != real".to_string()) });
+        }
+        if (__v_6 != __v_15) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_15.as_canonical_u64(), msg: Some("Reveal: claimed numeric field != real".to_string()) });
+        }
+        if (__v_7 != __v_16) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_16.as_canonical_u64(), msg: Some("Reveal: claimed numeric field != real".to_string()) });
+        }
+        let __ret: [G; OUT_689] = [];
+        record.function_queries[689].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+        return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_757: usize = 1;
-const IN_757: usize = 1;
-const OUT_757: usize = 1;
-fn aiur_fn_757(
-  inp: [G; IN_757],
+const INPUT_SIZE_690: usize = 3;
+const IN_690: usize = 3;
+const OUT_690: usize = 0;
+fn aiur_fn_690(
+  inp: [G; IN_690],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_757], ExecError> {
+) -> Result<[G; OUT_690], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    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_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 = G::from_u64(1);
-    let __io_pair: (G, G) = { let __key: [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 __info = io_buffer.get_info(__v_33, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) };
-    let __v_34: G = __io_pair.0;
-    let __v_35: G = __io_pair.1;
-    let __v_36: G = G::from_u64(1);
-    let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_36, __v_34, __v_35]; let __cu = true; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { let __ret: [G; OUT_0] = unsafe { *(result.output.as_ptr() as *const [G; OUT_0]) }; __ret } else { aiur_fn_0(__args, record, io_buffer, __cu)? } };
-    let __v_37: G = __r_arr[0];
-    let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[70].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_70] = unsafe { *(result.output.as_ptr() as *const [G; OUT_70]) }; __ret } else { aiur_fn_70(__args, record, io_buffer, __cu)? } };
-    let __v_38: G = __r_arr[0];
-    let __v_39: G = __r_arr[1];
-    let __v_40: G = __r_arr[2];
-    let __v_41: G = __r_arr[3];
-    let __v_42: G = __r_arr[4];
-    let __v_43: G = __r_arr[5];
-    let __v_44: G = __r_arr[6];
-    let __v_45: G = __r_arr[7];
-    let __v_46: G = __r_arr[8];
-    let __v_47: G = __r_arr[9];
-    let __r_arr: [G; OUT_756] = { let __args: [G; IN_756] = [__v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[756].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_756] = unsafe { *(result.output.as_ptr() as *const [G; OUT_756]) }; __ret } else { aiur_fn_756(__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];
-    let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; 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: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
-    let __v_51: G = __loaded[0];
-    let __v_52: G = __loaded[1];
-    let __v_53: G = __loaded[2];
-    let __v_54: G = __loaded[3];
-    let __v_55: G = __loaded[4];
-    let __v_56: G = __loaded[5];
-    let __v_57: G = __loaded[6];
-    let __v_58: G = __loaded[7];
-    let __v_59: G = __loaded[8];
-    let __v_60: G = __loaded[9];
-    let __v_61: G = __loaded[10];
-    let __v_62: G = __loaded[11];
-    let __v_63: G = __loaded[12];
-    let __v_64: G = __loaded[13];
-    let __v_65: G = __loaded[14];
-    let __v_66: G = __loaded[15];
-    let __v_67: G = __loaded[16];
-    let __v_68: G = __loaded[17];
-    let __v_69: G = __loaded[18];
-    let __v_70: G = __loaded[19];
-    let __v_71: G = __loaded[20];
-    let __v_72: G = __loaded[21];
-    let __v_73: G = __loaded[22];
-    let __v_74: G = __loaded[23];
-    let __v_75: G = __loaded[24];
-    let __v_76: G = __loaded[25];
-    let __v_77: G = __loaded[26];
-    let __v_78: G = __loaded[27];
-    let __v_79: G = __loaded[28];
-    let __v_80: G = __loaded[29];
-    let __v_81: G = __loaded[30];
-    let __v_82: G = __loaded[31];
-    let __v_83: G = G::from_u64(14);
-    if (__v_38 != __v_83) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_38.as_canonical_u64(), rhs: __v_83.as_canonical_u64() });
-    }
-    let __v_84: G = G::from_u64(2);
-    if (__v_39 != __v_84) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_39.as_canonical_u64(), rhs: __v_84.as_canonical_u64() });
-    }
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_50.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).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];
-    let __v_88: G = G::from_u64(1);
-    let __v_89: G = G::from_u64(1);
-    if (__v_85 != __v_88) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_85.as_canonical_u64(), rhs: __v_88.as_canonical_u64() });
-    }
-    if (__v_86 != __v_89) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_86.as_canonical_u64(), rhs: __v_89.as_canonical_u64() });
-    }
-    if (__v_87 != __v_89) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_87.as_canonical_u64(), rhs: __v_89.as_canonical_u64() });
-    }
-    if (__v_51 != __v_1) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_51.as_canonical_u64(), rhs: __v_1.as_canonical_u64() });
-    }
-    if (__v_52 != __v_2) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_52.as_canonical_u64(), rhs: __v_2.as_canonical_u64() });
-    }
-    if (__v_53 != __v_3) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_53.as_canonical_u64(), rhs: __v_3.as_canonical_u64() });
-    }
-    if (__v_54 != __v_4) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_54.as_canonical_u64(), rhs: __v_4.as_canonical_u64() });
-    }
-    if (__v_55 != __v_5) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_55.as_canonical_u64(), rhs: __v_5.as_canonical_u64() });
-    }
-    if (__v_56 != __v_6) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_56.as_canonical_u64(), rhs: __v_6.as_canonical_u64() });
-    }
-    if (__v_57 != __v_7) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_57.as_canonical_u64(), rhs: __v_7.as_canonical_u64() });
-    }
-    if (__v_58 != __v_8) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_58.as_canonical_u64(), rhs: __v_8.as_canonical_u64() });
-    }
-    if (__v_59 != __v_9) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_59.as_canonical_u64(), rhs: __v_9.as_canonical_u64() });
-    }
-    if (__v_60 != __v_10) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_60.as_canonical_u64(), rhs: __v_10.as_canonical_u64() });
-    }
-    if (__v_61 != __v_11) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_61.as_canonical_u64(), rhs: __v_11.as_canonical_u64() });
-    }
-    if (__v_62 != __v_12) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_62.as_canonical_u64(), rhs: __v_12.as_canonical_u64() });
-    }
-    if (__v_63 != __v_13) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_63.as_canonical_u64(), rhs: __v_13.as_canonical_u64() });
-    }
-    if (__v_64 != __v_14) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_64.as_canonical_u64(), rhs: __v_14.as_canonical_u64() });
-    }
-    if (__v_65 != __v_15) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_65.as_canonical_u64(), rhs: __v_15.as_canonical_u64() });
-    }
-    if (__v_66 != __v_16) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_66.as_canonical_u64(), rhs: __v_16.as_canonical_u64() });
-    }
-    if (__v_67 != __v_17) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_67.as_canonical_u64(), rhs: __v_17.as_canonical_u64() });
-    }
-    if (__v_68 != __v_18) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_68.as_canonical_u64(), rhs: __v_18.as_canonical_u64() });
-    }
-    if (__v_69 != __v_19) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_69.as_canonical_u64(), rhs: __v_19.as_canonical_u64() });
-    }
-    if (__v_70 != __v_20) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_70.as_canonical_u64(), rhs: __v_20.as_canonical_u64() });
-    }
-    if (__v_71 != __v_21) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_71.as_canonical_u64(), rhs: __v_21.as_canonical_u64() });
-    }
-    if (__v_72 != __v_22) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_72.as_canonical_u64(), rhs: __v_22.as_canonical_u64() });
-    }
-    if (__v_73 != __v_23) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_73.as_canonical_u64(), rhs: __v_23.as_canonical_u64() });
-    }
-    if (__v_74 != __v_24) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_74.as_canonical_u64(), rhs: __v_24.as_canonical_u64() });
-    }
-    if (__v_75 != __v_25) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_75.as_canonical_u64(), rhs: __v_25.as_canonical_u64() });
-    }
-    if (__v_76 != __v_26) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_76.as_canonical_u64(), rhs: __v_26.as_canonical_u64() });
-    }
-    if (__v_77 != __v_27) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_77.as_canonical_u64(), rhs: __v_27.as_canonical_u64() });
-    }
-    if (__v_78 != __v_28) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_78.as_canonical_u64(), rhs: __v_28.as_canonical_u64() });
-    }
-    if (__v_79 != __v_29) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_79.as_canonical_u64(), rhs: __v_29.as_canonical_u64() });
-    }
-    if (__v_80 != __v_30) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_80.as_canonical_u64(), rhs: __v_30.as_canonical_u64() });
-    }
-    if (__v_81 != __v_31) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_81.as_canonical_u64(), rhs: __v_31.as_canonical_u64() });
-    }
-    if (__v_82 != __v_32) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_82.as_canonical_u64(), rhs: __v_32.as_canonical_u64() });
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    match __v_1.as_canonical_u64() {
+      1u64 => {
+        let __ret: [G; OUT_690] = [];
+        record.function_queries[690].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_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_3: G = __loaded[0];
+        let __v_4: G = __loaded[1];
+        let __v_5: G = __loaded[2];
+        let __v_6: G = __loaded[3];
+        let __v_7: G = __loaded[4];
+        let __v_8: G = __loaded[5];
+        let __v_9: G = __loaded[6];
+        let __v_10: G = __loaded[7];
+        let __v_11: G = __loaded[8];
+        let __v_12: G = __loaded[9];
+        let __v_13: G = __loaded[10];
+        let __v_14: G = __loaded[11];
+        let __v_15: G = __loaded[12];
+        let __v_16: G = __loaded[13];
+        let __v_17: G = __loaded[14];
+        let __v_18: G = __loaded[15];
+        let __v_19: G = __loaded[16];
+        let __v_20: G = __loaded[17];
+        let __v_21: G = __loaded[18];
+        let __v_22: G = __loaded[19];
+        let __v_23: G = __loaded[20];
+        let __v_24: G = __loaded[21];
+        let __v_25: G = __loaded[22];
+        let __v_26: G = __loaded[23];
+        let __v_27: G = __loaded[24];
+        let __v_28: G = __loaded[25];
+        let __v_29: G = __loaded[26];
+        let __v_30: G = __loaded[27];
+        let __v_31: G = __loaded[28];
+        let __v_32: G = __loaded[29];
+        let __v_33: G = __loaded[30];
+        let __v_34: G = __loaded[31];
+        let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; 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: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].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];
+        if (__v_3 != __v_35) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_35.as_canonical_u64(), msg: Some("Reveal: claimed address field != real".to_string()) });
+        }
+        if (__v_4 != __v_36) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_4.as_canonical_u64(), rhs: __v_36.as_canonical_u64(), msg: Some("Reveal: claimed address field != real".to_string()) });
+        }
+        if (__v_5 != __v_37) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_37.as_canonical_u64(), msg: Some("Reveal: claimed address field != real".to_string()) });
+        }
+        if (__v_6 != __v_38) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_38.as_canonical_u64(), msg: Some("Reveal: claimed address field != real".to_string()) });
+        }
+        if (__v_7 != __v_39) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_39.as_canonical_u64(), msg: Some("Reveal: claimed address field != real".to_string()) });
+        }
+        if (__v_8 != __v_40) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_8.as_canonical_u64(), rhs: __v_40.as_canonical_u64(), msg: Some("Reveal: claimed address field != real".to_string()) });
+        }
+        if (__v_9 != __v_41) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_41.as_canonical_u64(), msg: Some("Reveal: claimed address field != real".to_string()) });
+        }
+        if (__v_10 != __v_42) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_10.as_canonical_u64(), rhs: __v_42.as_canonical_u64(), msg: Some("Reveal: claimed address field != real".to_string()) });
+        }
+        if (__v_11 != __v_43) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_43.as_canonical_u64(), msg: Some("Reveal: claimed address field != real".to_string()) });
+        }
+        if (__v_12 != __v_44) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_12.as_canonical_u64(), rhs: __v_44.as_canonical_u64(), msg: Some("Reveal: claimed address field != real".to_string()) });
+        }
+        if (__v_13 != __v_45) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_45.as_canonical_u64(), msg: Some("Reveal: claimed address field != real".to_string()) });
+        }
+        if (__v_14 != __v_46) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_14.as_canonical_u64(), rhs: __v_46.as_canonical_u64(), msg: Some("Reveal: claimed address field != real".to_string()) });
+        }
+        if (__v_15 != __v_47) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_15.as_canonical_u64(), rhs: __v_47.as_canonical_u64(), msg: Some("Reveal: claimed address field != real".to_string()) });
+        }
+        if (__v_16 != __v_48) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_48.as_canonical_u64(), msg: Some("Reveal: claimed address field != real".to_string()) });
+        }
+        if (__v_17 != __v_49) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_17.as_canonical_u64(), rhs: __v_49.as_canonical_u64(), msg: Some("Reveal: claimed address field != real".to_string()) });
+        }
+        if (__v_18 != __v_50) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_18.as_canonical_u64(), rhs: __v_50.as_canonical_u64(), msg: Some("Reveal: claimed address field != real".to_string()) });
+        }
+        if (__v_19 != __v_51) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_19.as_canonical_u64(), rhs: __v_51.as_canonical_u64(), msg: Some("Reveal: claimed address field != real".to_string()) });
+        }
+        if (__v_20 != __v_52) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_20.as_canonical_u64(), rhs: __v_52.as_canonical_u64(), msg: Some("Reveal: claimed address field != real".to_string()) });
+        }
+        if (__v_21 != __v_53) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_21.as_canonical_u64(), rhs: __v_53.as_canonical_u64(), msg: Some("Reveal: claimed address field != real".to_string()) });
+        }
+        if (__v_22 != __v_54) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_22.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: Some("Reveal: claimed address field != real".to_string()) });
+        }
+        if (__v_23 != __v_55) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_23.as_canonical_u64(), rhs: __v_55.as_canonical_u64(), msg: Some("Reveal: claimed address field != real".to_string()) });
+        }
+        if (__v_24 != __v_56) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_24.as_canonical_u64(), rhs: __v_56.as_canonical_u64(), msg: Some("Reveal: claimed address field != real".to_string()) });
+        }
+        if (__v_25 != __v_57) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_25.as_canonical_u64(), rhs: __v_57.as_canonical_u64(), msg: Some("Reveal: claimed address field != real".to_string()) });
+        }
+        if (__v_26 != __v_58) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_26.as_canonical_u64(), rhs: __v_58.as_canonical_u64(), msg: Some("Reveal: claimed address field != real".to_string()) });
+        }
+        if (__v_27 != __v_59) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_27.as_canonical_u64(), rhs: __v_59.as_canonical_u64(), msg: Some("Reveal: claimed address field != real".to_string()) });
+        }
+        if (__v_28 != __v_60) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_28.as_canonical_u64(), rhs: __v_60.as_canonical_u64(), msg: Some("Reveal: claimed address field != real".to_string()) });
+        }
+        if (__v_29 != __v_61) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_29.as_canonical_u64(), rhs: __v_61.as_canonical_u64(), msg: Some("Reveal: claimed address field != real".to_string()) });
+        }
+        if (__v_30 != __v_62) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_30.as_canonical_u64(), rhs: __v_62.as_canonical_u64(), msg: Some("Reveal: claimed address field != real".to_string()) });
+        }
+        if (__v_31 != __v_63) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_31.as_canonical_u64(), rhs: __v_63.as_canonical_u64(), msg: Some("Reveal: claimed address field != real".to_string()) });
+        }
+        if (__v_32 != __v_64) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_32.as_canonical_u64(), rhs: __v_64.as_canonical_u64(), msg: Some("Reveal: claimed address field != real".to_string()) });
+        }
+        if (__v_33 != __v_65) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_33.as_canonical_u64(), rhs: __v_65.as_canonical_u64(), msg: Some("Reveal: claimed address field != real".to_string()) });
+        }
+        if (__v_34 != __v_66) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_34.as_canonical_u64(), rhs: __v_66.as_canonical_u64(), msg: Some("Reveal: claimed address field != real".to_string()) });
+        }
+        let __ret: [G; OUT_690] = [];
+        record.function_queries[690].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+      },
     }
-    let __ret: [G; OUT_757] = [__v_49];
-    record.function_queries[757].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_758: usize = 2;
-const IN_758: usize = 2;
-const OUT_758: usize = 1;
-fn aiur_fn_758(
-  inp: [G; IN_758],
+const INPUT_SIZE_691: usize = 3;
+const IN_691: usize = 3;
+const OUT_691: usize = 0;
+fn aiur_fn_691(
+  inp: [G; IN_691],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_758], ExecError> {
+) -> Result<[G; OUT_691], 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() {
+    let __v_2: G = inp[2];
+    match __v_1.as_canonical_u64() {
       1u64 => {
-        let __v_5: G = G::from_u64(0);
-        let __ret: [G; OUT_758] = [__v_5];
-        record.function_queries[758].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_691] = [];
+        record.function_queries[691].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { 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];
-        match __v_5.as_canonical_u64() {
-          1u64 => {
-            let __v_6: G = G::from_u64(1);
-            let __ret: [G; OUT_758] = [__v_6];
-            record.function_queries[758].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            let __r_arr: [G; OUT_758] = { let __args: [G; IN_758] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[758].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_758] = unsafe { *(result.output.as_ptr() as *const [G; OUT_758]) }; __ret } else { aiur_fn_758(__args, record, io_buffer, __cu)? } };
-            let __v_6: G = __r_arr[0];
-            let __ret: [G; OUT_758] = [__v_6];
-            record.function_queries[758].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
+        let __r_arr: [G; OUT_683] = { let __args: [G; IN_683] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[683].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_683] = unsafe { *(result.output.as_ptr() as *const [G; OUT_683]) }; __ret } else { aiur_fn_683(__args, record, io_buffer, __cu)? } };
+        let __v_3: G = __r_arr[0];
+        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_4: G = __loaded[0];
+        let __v_5: G = __loaded[1];
+        let __v_6: G = __loaded[2];
+        let __v_7: G = __loaded[3];
+        let __v_8: G = __loaded[4];
+        let __v_9: G = __loaded[5];
+        let __v_10: G = __loaded[6];
+        let __v_11: G = __loaded[7];
+        let __v_12: G = __loaded[8];
+        let __v_13: G = __loaded[9];
+        let __v_14: G = __loaded[10];
+        let __v_15: G = __loaded[11];
+        let __v_16: G = __loaded[12];
+        let __v_17: G = __loaded[13];
+        let __v_18: G = __loaded[14];
+        let __v_19: G = __loaded[15];
+        let __v_20: G = __loaded[16];
+        let __v_21: G = __loaded[17];
+        let __v_22: G = __loaded[18];
+        let __v_23: G = __loaded[19];
+        let __v_24: G = __loaded[20];
+        let __v_25: G = __loaded[21];
+        let __v_26: G = __loaded[22];
+        let __v_27: G = __loaded[23];
+        let __v_28: G = __loaded[24];
+        let __v_29: G = __loaded[25];
+        let __v_30: G = __loaded[26];
+        let __v_31: G = __loaded[27];
+        let __v_32: G = __loaded[28];
+        let __v_33: G = __loaded[29];
+        let __v_34: G = __loaded[30];
+        let __v_35: G = __loaded[31];
+        let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; 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: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+        let __v_36: G = __loaded[0];
+        let __v_37: G = __loaded[1];
+        let __v_38: G = __loaded[2];
+        let __v_39: G = __loaded[3];
+        let __v_40: G = __loaded[4];
+        let __v_41: G = __loaded[5];
+        let __v_42: G = __loaded[6];
+        let __v_43: G = __loaded[7];
+        let __v_44: G = __loaded[8];
+        let __v_45: G = __loaded[9];
+        let __v_46: G = __loaded[10];
+        let __v_47: G = __loaded[11];
+        let __v_48: G = __loaded[12];
+        let __v_49: G = __loaded[13];
+        let __v_50: G = __loaded[14];
+        let __v_51: G = __loaded[15];
+        let __v_52: G = __loaded[16];
+        let __v_53: G = __loaded[17];
+        let __v_54: G = __loaded[18];
+        let __v_55: G = __loaded[19];
+        let __v_56: G = __loaded[20];
+        let __v_57: G = __loaded[21];
+        let __v_58: G = __loaded[22];
+        let __v_59: G = __loaded[23];
+        let __v_60: G = __loaded[24];
+        let __v_61: G = __loaded[25];
+        let __v_62: G = __loaded[26];
+        let __v_63: G = __loaded[27];
+        let __v_64: G = __loaded[28];
+        let __v_65: G = __loaded[29];
+        let __v_66: G = __loaded[30];
+        let __v_67: G = __loaded[31];
+        if (__v_4 != __v_36) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_4.as_canonical_u64(), rhs: __v_36.as_canonical_u64(), msg: Some("Reveal: claimed expr hash != hash of the real expr".to_string()) });
+        }
+        if (__v_5 != __v_37) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_37.as_canonical_u64(), msg: Some("Reveal: claimed expr hash != hash of the real expr".to_string()) });
+        }
+        if (__v_6 != __v_38) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_38.as_canonical_u64(), msg: Some("Reveal: claimed expr hash != hash of the real expr".to_string()) });
+        }
+        if (__v_7 != __v_39) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_39.as_canonical_u64(), msg: Some("Reveal: claimed expr hash != hash of the real expr".to_string()) });
+        }
+        if (__v_8 != __v_40) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_8.as_canonical_u64(), rhs: __v_40.as_canonical_u64(), msg: Some("Reveal: claimed expr hash != hash of the real expr".to_string()) });
+        }
+        if (__v_9 != __v_41) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_41.as_canonical_u64(), msg: Some("Reveal: claimed expr hash != hash of the real expr".to_string()) });
+        }
+        if (__v_10 != __v_42) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_10.as_canonical_u64(), rhs: __v_42.as_canonical_u64(), msg: Some("Reveal: claimed expr hash != hash of the real expr".to_string()) });
+        }
+        if (__v_11 != __v_43) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_43.as_canonical_u64(), msg: Some("Reveal: claimed expr hash != hash of the real expr".to_string()) });
+        }
+        if (__v_12 != __v_44) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_12.as_canonical_u64(), rhs: __v_44.as_canonical_u64(), msg: Some("Reveal: claimed expr hash != hash of the real expr".to_string()) });
+        }
+        if (__v_13 != __v_45) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_45.as_canonical_u64(), msg: Some("Reveal: claimed expr hash != hash of the real expr".to_string()) });
+        }
+        if (__v_14 != __v_46) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_14.as_canonical_u64(), rhs: __v_46.as_canonical_u64(), msg: Some("Reveal: claimed expr hash != hash of the real expr".to_string()) });
+        }
+        if (__v_15 != __v_47) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_15.as_canonical_u64(), rhs: __v_47.as_canonical_u64(), msg: Some("Reveal: claimed expr hash != hash of the real expr".to_string()) });
+        }
+        if (__v_16 != __v_48) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_48.as_canonical_u64(), msg: Some("Reveal: claimed expr hash != hash of the real expr".to_string()) });
+        }
+        if (__v_17 != __v_49) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_17.as_canonical_u64(), rhs: __v_49.as_canonical_u64(), msg: Some("Reveal: claimed expr hash != hash of the real expr".to_string()) });
+        }
+        if (__v_18 != __v_50) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_18.as_canonical_u64(), rhs: __v_50.as_canonical_u64(), msg: Some("Reveal: claimed expr hash != hash of the real expr".to_string()) });
+        }
+        if (__v_19 != __v_51) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_19.as_canonical_u64(), rhs: __v_51.as_canonical_u64(), msg: Some("Reveal: claimed expr hash != hash of the real expr".to_string()) });
+        }
+        if (__v_20 != __v_52) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_20.as_canonical_u64(), rhs: __v_52.as_canonical_u64(), msg: Some("Reveal: claimed expr hash != hash of the real expr".to_string()) });
+        }
+        if (__v_21 != __v_53) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_21.as_canonical_u64(), rhs: __v_53.as_canonical_u64(), msg: Some("Reveal: claimed expr hash != hash of the real expr".to_string()) });
+        }
+        if (__v_22 != __v_54) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_22.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: Some("Reveal: claimed expr hash != hash of the real expr".to_string()) });
         }
+        if (__v_23 != __v_55) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_23.as_canonical_u64(), rhs: __v_55.as_canonical_u64(), msg: Some("Reveal: claimed expr hash != hash of the real expr".to_string()) });
+        }
+        if (__v_24 != __v_56) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_24.as_canonical_u64(), rhs: __v_56.as_canonical_u64(), msg: Some("Reveal: claimed expr hash != hash of the real expr".to_string()) });
+        }
+        if (__v_25 != __v_57) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_25.as_canonical_u64(), rhs: __v_57.as_canonical_u64(), msg: Some("Reveal: claimed expr hash != hash of the real expr".to_string()) });
+        }
+        if (__v_26 != __v_58) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_26.as_canonical_u64(), rhs: __v_58.as_canonical_u64(), msg: Some("Reveal: claimed expr hash != hash of the real expr".to_string()) });
+        }
+        if (__v_27 != __v_59) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_27.as_canonical_u64(), rhs: __v_59.as_canonical_u64(), msg: Some("Reveal: claimed expr hash != hash of the real expr".to_string()) });
+        }
+        if (__v_28 != __v_60) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_28.as_canonical_u64(), rhs: __v_60.as_canonical_u64(), msg: Some("Reveal: claimed expr hash != hash of the real expr".to_string()) });
+        }
+        if (__v_29 != __v_61) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_29.as_canonical_u64(), rhs: __v_61.as_canonical_u64(), msg: Some("Reveal: claimed expr hash != hash of the real expr".to_string()) });
+        }
+        if (__v_30 != __v_62) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_30.as_canonical_u64(), rhs: __v_62.as_canonical_u64(), msg: Some("Reveal: claimed expr hash != hash of the real expr".to_string()) });
+        }
+        if (__v_31 != __v_63) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_31.as_canonical_u64(), rhs: __v_63.as_canonical_u64(), msg: Some("Reveal: claimed expr hash != hash of the real expr".to_string()) });
+        }
+        if (__v_32 != __v_64) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_32.as_canonical_u64(), rhs: __v_64.as_canonical_u64(), msg: Some("Reveal: claimed expr hash != hash of the real expr".to_string()) });
+        }
+        if (__v_33 != __v_65) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_33.as_canonical_u64(), rhs: __v_65.as_canonical_u64(), msg: Some("Reveal: claimed expr hash != hash of the real expr".to_string()) });
+        }
+        if (__v_34 != __v_66) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_34.as_canonical_u64(), rhs: __v_66.as_canonical_u64(), msg: Some("Reveal: claimed expr hash != hash of the real expr".to_string()) });
+        }
+        if (__v_35 != __v_67) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_35.as_canonical_u64(), rhs: __v_67.as_canonical_u64(), msg: Some("Reveal: claimed expr hash != hash of the real expr".to_string()) });
+        }
+        let __ret: [G; OUT_691] = [];
+        record.function_queries[691].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_759: usize = 1;
-const IN_759: usize = 1;
-const OUT_759: usize = 1;
-fn aiur_fn_759(
-  inp: [G; IN_759],
+const INPUT_SIZE_692: usize = 10;
+const IN_692: usize = 10;
+const OUT_692: usize = 0;
+fn aiur_fn_692(
+  inp: [G; IN_692],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_759], ExecError> {
+) -> Result<[G; OUT_692], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    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_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 = G::from_u64(256);
-    let __v_34: G = (__v_2 * __v_33);
-    let __v_35: G = G::from_u64(65536);
-    let __v_36: G = (__v_3 * __v_35);
-    let __v_37: G = G::from_u64(16777216);
-    let __v_38: G = (__v_4 * __v_37);
-    let __v_39: G = (__v_36 + __v_38);
-    let __v_40: G = (__v_34 + __v_39);
-    let __v_41: G = (__v_1 + __v_40);
-    let __ret: [G; OUT_759] = [__v_41];
-    record.function_queries[759].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
+    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 __loaded: [G; 19] = { let __mq = record.memory_queries.get_mut(&19).ok_or(ExecError::InvalidMemorySize(19))?; 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: 19 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 19] = __args[..19].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];
+    match __v_10.as_canonical_u64() {
+      1u64 => {
+        let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr };
+        let __v_29: G = __loaded[0];
+        let __v_30: G = __loaded[1];
+        let __v_31: G = __loaded[2];
+        let __v_32: G = __loaded[3];
+        let __v_33: G = __loaded[4];
+        let __v_34: G = __loaded[5];
+        let __v_35: G = __loaded[6];
+        let __v_36: G = __loaded[7];
+        let __v_37: G = __loaded[8];
+        let __v_38: G = __loaded[9];
+        let __v_39: G = __loaded[10];
+        match __v_29.as_canonical_u64() {
+          1u64 => {
+            let __ret: [G; OUT_692] = [];
+            record.function_queries[692].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_29.as_canonical_u64()));
+          },
+        }
+      },
+      0u64 => {
+        let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr };
+        let __v_29: G = __loaded[0];
+        let __v_30: G = __loaded[1];
+        let __v_31: G = __loaded[2];
+        let __v_32: G = __loaded[3];
+        let __v_33: G = __loaded[4];
+        let __v_34: G = __loaded[5];
+        let __v_35: G = __loaded[6];
+        let __v_36: G = __loaded[7];
+        let __v_37: G = __loaded[8];
+        let __v_38: G = __loaded[9];
+        let __v_39: G = __loaded[10];
+        match __v_29.as_canonical_u64() {
+          0u64 => {
+            match __v_11.as_canonical_u64() {
+              _ => {
+                match __v_30.as_canonical_u64() {
+                  _ => {
+                    let __v_40: G = G::from_u64(0);
+                    let __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__v_38, __v_40, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[691].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_691] = unsafe { *(result.output.as_ptr() as *const [G; OUT_691]) }; __ret } else { aiur_fn_691(__args, record, io_buffer, __cu)? } };
+                    if (__v_11 != __v_2) {
+                      return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("Reveal: claimed recursor rule index != its position".to_string()) });
+                    }
+                    if (__v_12 != __v_3) {
+                      return Err(ExecError::AssertEqMismatch { lhs: __v_12.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: Some("Reveal: claimed recursor rule index != its position".to_string()) });
+                    }
+                    if (__v_13 != __v_4) {
+                      return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("Reveal: claimed recursor rule index != its position".to_string()) });
+                    }
+                    if (__v_14 != __v_5) {
+                      return Err(ExecError::AssertEqMismatch { lhs: __v_14.as_canonical_u64(), rhs: __v_5.as_canonical_u64(), msg: Some("Reveal: claimed recursor rule index != its position".to_string()) });
+                    }
+                    if (__v_15 != __v_6) {
+                      return Err(ExecError::AssertEqMismatch { lhs: __v_15.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: Some("Reveal: claimed recursor rule index != its position".to_string()) });
+                    }
+                    if (__v_16 != __v_7) {
+                      return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_7.as_canonical_u64(), msg: Some("Reveal: claimed recursor rule index != its position".to_string()) });
+                    }
+                    if (__v_17 != __v_8) {
+                      return Err(ExecError::AssertEqMismatch { lhs: __v_17.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("Reveal: claimed recursor rule index != its position".to_string()) });
+                    }
+                    if (__v_18 != __v_9) {
+                      return Err(ExecError::AssertEqMismatch { lhs: __v_18.as_canonical_u64(), rhs: __v_9.as_canonical_u64(), msg: Some("Reveal: claimed recursor rule index != its position".to_string()) });
+                    }
+                    if (__v_30 != __v_19) {
+                      return Err(ExecError::AssertEqMismatch { lhs: __v_30.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: Some("Reveal: claimed recursor rule field count != real".to_string()) });
+                    }
+                    if (__v_31 != __v_20) {
+                      return Err(ExecError::AssertEqMismatch { lhs: __v_31.as_canonical_u64(), rhs: __v_20.as_canonical_u64(), msg: Some("Reveal: claimed recursor rule field count != real".to_string()) });
+                    }
+                    if (__v_32 != __v_21) {
+                      return Err(ExecError::AssertEqMismatch { lhs: __v_32.as_canonical_u64(), rhs: __v_21.as_canonical_u64(), msg: Some("Reveal: claimed recursor rule field count != real".to_string()) });
+                    }
+                    if (__v_33 != __v_22) {
+                      return Err(ExecError::AssertEqMismatch { lhs: __v_33.as_canonical_u64(), rhs: __v_22.as_canonical_u64(), msg: Some("Reveal: claimed recursor rule field count != real".to_string()) });
+                    }
+                    if (__v_34 != __v_23) {
+                      return Err(ExecError::AssertEqMismatch { lhs: __v_34.as_canonical_u64(), rhs: __v_23.as_canonical_u64(), msg: Some("Reveal: claimed recursor rule field count != real".to_string()) });
+                    }
+                    if (__v_35 != __v_24) {
+                      return Err(ExecError::AssertEqMismatch { lhs: __v_35.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: Some("Reveal: claimed recursor rule field count != real".to_string()) });
+                    }
+                    if (__v_36 != __v_25) {
+                      return Err(ExecError::AssertEqMismatch { lhs: __v_36.as_canonical_u64(), rhs: __v_25.as_canonical_u64(), msg: Some("Reveal: claimed recursor rule field count != real".to_string()) });
+                    }
+                    if (__v_37 != __v_26) {
+                      return Err(ExecError::AssertEqMismatch { lhs: __v_37.as_canonical_u64(), rhs: __v_26.as_canonical_u64(), msg: Some("Reveal: claimed recursor rule field count != real".to_string()) });
+                    }
+                    let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__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 __r_arr: [G; OUT_692] = { let __args: [G; IN_692] = [__v_39, __v_28, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[692].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_692] = unsafe { *(result.output.as_ptr() as *const [G; OUT_692]) }; __ret } else { aiur_fn_692(__args, record, io_buffer, __cu)? } };
+                    let __ret: [G; OUT_692] = [];
+                    record.function_queries[692].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    return Ok(__ret);
+                  },
+                }
+              },
+            }
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_29.as_canonical_u64()));
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64()));
+      },
+    }
   })
 }
 
-const INPUT_SIZE_760: usize = 1;
-const IN_760: usize = 1;
-const OUT_760: usize = 6;
-fn aiur_fn_760(
-  inp: [G; IN_760],
+const INPUT_SIZE_693: usize = 3;
+const IN_693: usize = 3;
+const OUT_693: usize = 0;
+fn aiur_fn_693(
+  inp: [G; IN_693],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_760], ExecError> {
+) -> Result<[G; OUT_693], 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];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
     match __v_1.as_canonical_u64() {
       1u64 => {
-        let __v_4: G = G::from_u64(1);
-        let __v_5: G = G::from_u64(1);
-        let __ret: [G; OUT_760] = [__v_4, __v_5, __v_5, __v_5, __v_5, __v_5];
-        record.function_queries[760].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_693] = [];
+        record.function_queries[693].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __v_4: G = G::from_u64(1);
-        let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } else { aiur_fn_760(__args, record, io_buffer, __cu)? } };
-        let __v_5: G = __r_arr[0];
-        let __v_6: G = __r_arr[1];
-        let __v_7: G = __r_arr[2];
-        let __v_8: G = __r_arr[3];
-        let __v_9: G = __r_arr[4];
-        let __v_10: G = __r_arr[5];
-        let __r_arr: [G; OUT_785] = { let __args: [G; IN_785] = [__v_2, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[785].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_785] = unsafe { *(result.output.as_ptr() as *const [G; OUT_785]) }; __ret } else { aiur_fn_785(__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 __ret: [G; OUT_760] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16];
-        record.function_queries[760].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __v_3: G = G::from_u64(0);
+        let __v_4: G = G::from_u64(0);
+        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 __r_arr: [G; OUT_692] = { let __args: [G; IN_692] = [__v_0, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[692].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_692] = unsafe { *(result.output.as_ptr() as *const [G; OUT_692]) }; __ret } else { aiur_fn_692(__args, record, io_buffer, __cu)? } };
+        let __ret: [G; OUT_693] = [];
+        record.function_queries[693].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -63773,153 +56913,226 @@ fn aiur_fn_760(
   })
 }
 
-const INPUT_SIZE_761: usize = 4;
-const IN_761: usize = 4;
-const OUT_761: usize = 0;
-fn aiur_fn_761(
-  inp: [G; IN_761],
+const INPUT_SIZE_694: usize = 49;
+const IN_694: usize = 49;
+const OUT_694: usize = 0;
+fn aiur_fn_694(
+  inp: [G; IN_694],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_761], ExecError> {
+) -> Result<[G; OUT_694], 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_684] = { let __args: [G; IN_684] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[684].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_684] = unsafe { *(result.output.as_ptr() as *const [G; OUT_684]) }; __ret } else { aiur_fn_684(__args, record, io_buffer, __cu)? } };
-    let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } else { aiur_fn_760(__args, record, io_buffer, __cu)? } };
-    let __v_4: G = __r_arr[0];
-    let __v_5: G = __r_arr[1];
-    let __v_6: G = __r_arr[2];
-    let __v_7: G = __r_arr[3];
-    let __v_8: G = __r_arr[4];
-    let __v_9: G = __r_arr[5];
-    let __v_10: G = { let __values: [G; 6] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; 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 __v_11: G = G::from_u64(0);
-    let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_1, __v_2, __v_2, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
-    let __ret: [G; OUT_761] = [];
-    record.function_queries[761].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
+    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 __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__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[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } };
+    let __v_49: G = __r_arr[0];
+    let __v_50: G = __r_arr[1];
+    let __v_51: G = __r_arr[2];
+    let __v_52: G = __r_arr[3];
+    let __v_53: G = __r_arr[4];
+    let __v_54: G = __r_arr[5];
+    let __v_55: G = __r_arr[6];
+    let __v_56: G = __r_arr[7];
+    let __v_57: G = __r_arr[8];
+    let __v_58: G = __r_arr[9];
+    let __v_59: G = __r_arr[10];
+    let __v_60: G = __r_arr[11];
+    let __v_61: G = __r_arr[12];
+    let __v_62: G = __r_arr[13];
+    let __v_63: G = __r_arr[14];
+    let __v_64: G = __r_arr[15];
+    let __v_65: G = __r_arr[16];
+    let __v_66: G = __r_arr[17];
+    let __v_67: G = __r_arr[18];
+    let __v_68: G = __r_arr[19];
+    let __v_69: G = __r_arr[20];
+    let __v_70: G = __r_arr[21];
+    let __v_71: G = __r_arr[22];
+    let __v_72: G = __r_arr[23];
+    let __v_73: G = __r_arr[24];
+    let __v_74: G = __r_arr[25];
+    let __v_75: G = __r_arr[26];
+    let __v_76: G = __r_arr[27];
+    let __v_77: G = __r_arr[28];
+    let __v_78: G = __r_arr[29];
+    let __v_79: G = __r_arr[30];
+    let __v_80: G = __r_arr[31];
+    let __v_81: G = __r_arr[32];
+    let __v_82: G = __r_arr[33];
+    match __v_9.as_canonical_u64() {
+      _ => {
+        match __v_49.as_canonical_u64() {
+          _ => {
+            let __r_arr: [G; OUT_688] = { let __args: [G; IN_688] = [__v_49, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[688].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_688] = unsafe { *(result.output.as_ptr() as *const [G; OUT_688]) }; __ret } else { aiur_fn_688(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_689] = { let __args: [G; IN_689] = [__v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_11, __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[689].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_689] = unsafe { *(result.output.as_ptr() as *const [G; OUT_689]) }; __ret } else { aiur_fn_689(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_689] = { let __args: [G; IN_689] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[689].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_689] = unsafe { *(result.output.as_ptr() as *const [G; OUT_689]) }; __ret } else { aiur_fn_689(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_689] = { let __args: [G; IN_689] = [__v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __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[689].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_689] = unsafe { *(result.output.as_ptr() as *const [G; OUT_689]) }; __ret } else { aiur_fn_689(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_689] = { let __args: [G; IN_689] = [__v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[689].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_689] = unsafe { *(result.output.as_ptr() as *const [G; OUT_689]) }; __ret } else { aiur_fn_689(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__v_82, __v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[691].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_691] = unsafe { *(result.output.as_ptr() as *const [G; OUT_691]) }; __ret } else { aiur_fn_691(__args, record, io_buffer, __cu)? } };
+            let __ret: [G; OUT_694] = [];
+            record.function_queries[694].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+        }
+      },
+    }
   })
 }
 
-const INPUT_SIZE_762: usize = 6;
-const IN_762: usize = 6;
-const OUT_762: usize = 0;
-fn aiur_fn_762(
-  inp: [G; IN_762],
+const INPUT_SIZE_695: usize = 2;
+const IN_695: usize = 2;
+const OUT_695: usize = 0;
+fn aiur_fn_695(
+  inp: [G; IN_695],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_762], ExecError> {
+) -> Result<[G; OUT_695], 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_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_6: G = __loaded[0];
-    let __v_7: G = __loaded[1];
-    let __v_8: G = __loaded[2];
-    match __v_6.as_canonical_u64() {
+    let __loaded: [G; 50] = { let __mq = record.memory_queries.get_mut(&50).ok_or(ExecError::InvalidMemorySize(50))?; 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: 50 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 50] = __args[..50].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];
+    let __v_12: G = __loaded[10];
+    let __v_13: G = __loaded[11];
+    let __v_14: G = __loaded[12];
+    let __v_15: G = __loaded[13];
+    let __v_16: G = __loaded[14];
+    let __v_17: G = __loaded[15];
+    let __v_18: G = __loaded[16];
+    let __v_19: G = __loaded[17];
+    let __v_20: G = __loaded[18];
+    let __v_21: G = __loaded[19];
+    let __v_22: G = __loaded[20];
+    let __v_23: G = __loaded[21];
+    let __v_24: G = __loaded[22];
+    let __v_25: G = __loaded[23];
+    let __v_26: G = __loaded[24];
+    let __v_27: G = __loaded[25];
+    let __v_28: G = __loaded[26];
+    let __v_29: G = __loaded[27];
+    let __v_30: G = __loaded[28];
+    let __v_31: G = __loaded[29];
+    let __v_32: G = __loaded[30];
+    let __v_33: G = __loaded[31];
+    let __v_34: G = __loaded[32];
+    let __v_35: G = __loaded[33];
+    let __v_36: G = __loaded[34];
+    let __v_37: G = __loaded[35];
+    let __v_38: G = __loaded[36];
+    let __v_39: G = __loaded[37];
+    let __v_40: G = __loaded[38];
+    let __v_41: G = __loaded[39];
+    let __v_42: G = __loaded[40];
+    let __v_43: G = __loaded[41];
+    let __v_44: G = __loaded[42];
+    let __v_45: G = __loaded[43];
+    let __v_46: G = __loaded[44];
+    let __v_47: G = __loaded[45];
+    let __v_48: G = __loaded[46];
+    let __v_49: G = __loaded[47];
+    let __v_50: G = __loaded[48];
+    let __v_51: G = __loaded[49];
+    match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_762] = [];
-        record.function_queries[762].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_695] = [];
+        record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].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 __v_17: G = __loaded[8];
-        let __v_18: G = __loaded[9];
-        let __v_19: G = __loaded[10];
-        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_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; 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_23: G = __loaded[0];
-            let __v_24: G = __loaded[1];
-            let __v_25: G = __loaded[2];
-            let __v_26: G = __loaded[3];
-            let __v_27: G = __loaded[4];
-            let __v_28: G = __loaded[5];
-            let __v_29: G = G::from_u64(0);
-            let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_21, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[774].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } else { aiur_fn_774(__args, record, io_buffer, __cu)? } };
-            let __v_30: G = __r_arr[0];
-            match __v_30.as_canonical_u64() {
-              0u64 => {
-                let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } };
-                let __v_31: G = G::from_u64(1);
-                let __v_32: G = (__v_5 + __v_31);
-                let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_8, __v_1, __v_2, __v_22, __v_4, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
-                let __ret: [G; OUT_762] = [];
-                record.function_queries[762].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              _ => {
-                let __v_31: G = G::from_u64(1);
-                let __v_32: G = (__v_5 + __v_31);
-                let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_8, __v_1, __v_2, __v_22, __v_4, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
-                let __ret: [G; OUT_762] = [];
-                record.function_queries[762].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-            }
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_20.as_canonical_u64()));
-          },
-        }
+        let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_0, __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_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]; let __cu = unconstrained; if let Some(result) = record.function_queries[694].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_694] = unsafe { *(result.output.as_ptr() as *const [G; OUT_694]) }; __ret } else { aiur_fn_694(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_0, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } else { aiur_fn_695(__args, record, io_buffer, __cu)? } };
+        let __ret: [G; OUT_695] = [];
+        record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64()));
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_763: usize = 3;
-const IN_763: usize = 3;
-const OUT_763: usize = 0;
-fn aiur_fn_763(
-  inp: [G; IN_763],
+const INPUT_SIZE_696: usize = 3;
+const IN_696: usize = 3;
+const OUT_696: usize = 0;
+fn aiur_fn_696(
+  inp: [G; IN_696],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_763], ExecError> {
+) -> Result<[G; OUT_696], 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_182] = { let __args: [G; IN_182] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[182].get_mut(&__args[..]) { 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_3: G = __r_arr[0];
-    let __v_4: G = __r_arr[1];
     match __v_1.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_3, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_763] = [];
-        record.function_queries[763].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_696] = [];
+        record.function_queries[696].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_757] = { let __args: [G; IN_757] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[757].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_757] = unsafe { *(result.output.as_ptr() as *const [G; OUT_757]) }; __ret } else { aiur_fn_757(__args, record, io_buffer, __cu)? } };
-        let __v_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_761] = { let __args: [G; IN_761] = [__v_3, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[761].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_761] = unsafe { *(result.output.as_ptr() as *const [G; OUT_761]) }; __ret } else { aiur_fn_761(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_763] = [];
-        record.function_queries[763].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } else { aiur_fn_695(__args, record, io_buffer, __cu)? } };
+        let __ret: [G; OUT_696] = [];
+        record.function_queries[696].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -63929,81 +57142,343 @@ fn aiur_fn_763(
   })
 }
 
-const INPUT_SIZE_764: usize = 2;
-const IN_764: usize = 2;
-const OUT_764: usize = 0;
-fn aiur_fn_764(
-  inp: [G; IN_764],
+const INPUT_SIZE_697: usize = 99;
+const IN_697: usize = 99;
+const OUT_697: usize = 0;
+fn aiur_fn_697(
+  inp: [G; IN_697],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_764], ExecError> {
+) -> Result<[G; OUT_697], 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_757] = { let __args: [G; IN_757] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[757].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_757] = unsafe { *(result.output.as_ptr() as *const [G; OUT_757]) }; __ret } else { aiur_fn_757(__args, record, io_buffer, __cu)? } };
-    let __v_2: G = __r_arr[0];
-    let __r_arr: [G; OUT_758] = { let __args: [G; IN_758] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[758].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_758] = unsafe { *(result.output.as_ptr() as *const [G; OUT_758]) }; __ret } else { aiur_fn_758(__args, record, io_buffer, __cu)? } };
-    let __v_3: G = __r_arr[0];
-    let __v_4: G = G::from_u64(1);
-    if (__v_3 != __v_4) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_4.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];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        match __v_45.as_canonical_u64() {
+          0u64 => {
+            match __v_1.as_canonical_u64() {
+              _ => {
+                let __r_arr: [G; OUT_685] = { let __args: [G; IN_685] = [__v_1, __v_46, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[685].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_685] = unsafe { *(result.output.as_ptr() as *const [G; OUT_685]) }; __ret } else { aiur_fn_685(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_686] = { let __args: [G; IN_686] = [__v_2, __v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[686].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_686] = unsafe { *(result.output.as_ptr() as *const [G; OUT_686]) }; __ret } else { aiur_fn_686(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_689] = { let __args: [G; IN_689] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[689].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_689] = unsafe { *(result.output.as_ptr() as *const [G; OUT_689]) }; __ret } else { aiur_fn_689(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__v_11, __v_59, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[691].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_691] = unsafe { *(result.output.as_ptr() as *const [G; OUT_691]) }; __ret } else { aiur_fn_691(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__v_12, __v_61, __v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[691].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_691] = unsafe { *(result.output.as_ptr() as *const [G; OUT_691]) }; __ret } else { aiur_fn_691(__args, record, io_buffer, __cu)? } };
+                let __ret: [G; OUT_697] = [];
+                record.function_queries[697].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+            }
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_45.as_canonical_u64()));
+          },
+        }
+      },
+      1u64 => {
+        match __v_45.as_canonical_u64() {
+          1u64 => {
+            match __v_1.as_canonical_u64() {
+              _ => {
+                let __r_arr: [G; OUT_688] = { let __args: [G; IN_688] = [__v_1, __v_46, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[688].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_688] = unsafe { *(result.output.as_ptr() as *const [G; OUT_688]) }; __ret } else { aiur_fn_688(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_689] = { let __args: [G; IN_689] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[689].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_689] = unsafe { *(result.output.as_ptr() as *const [G; OUT_689]) }; __ret } else { aiur_fn_689(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_689] = { let __args: [G; IN_689] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65]; let __cu = unconstrained; if let Some(result) = record.function_queries[689].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_689] = unsafe { *(result.output.as_ptr() as *const [G; OUT_689]) }; __ret } else { aiur_fn_689(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_689] = { let __args: [G; IN_689] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74]; let __cu = unconstrained; if let Some(result) = record.function_queries[689].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_689] = unsafe { *(result.output.as_ptr() as *const [G; OUT_689]) }; __ret } else { aiur_fn_689(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__v_26, __v_75, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[691].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_691] = unsafe { *(result.output.as_ptr() as *const [G; OUT_691]) }; __ret } else { aiur_fn_691(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_27, __v_77, __v_78]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } else { aiur_fn_696(__args, record, io_buffer, __cu)? } };
+                let __ret: [G; OUT_697] = [];
+                record.function_queries[697].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+            }
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_45.as_canonical_u64()));
+          },
+        }
+      },
+      2u64 => {
+        match __v_45.as_canonical_u64() {
+          2u64 => {
+            match __v_1.as_canonical_u64() {
+              _ => {
+                let __r_arr: [G; OUT_688] = { let __args: [G; IN_688] = [__v_1, __v_46, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[688].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_688] = unsafe { *(result.output.as_ptr() as *const [G; OUT_688]) }; __ret } else { aiur_fn_688(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_688] = { let __args: [G; IN_688] = [__v_2, __v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[688].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_688] = unsafe { *(result.output.as_ptr() as *const [G; OUT_688]) }; __ret } else { aiur_fn_688(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_689] = { let __args: [G; IN_689] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[689].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_689] = unsafe { *(result.output.as_ptr() as *const [G; OUT_689]) }; __ret } else { aiur_fn_689(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_689] = { let __args: [G; IN_689] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[689].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_689] = unsafe { *(result.output.as_ptr() as *const [G; OUT_689]) }; __ret } else { aiur_fn_689(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_689] = { let __args: [G; IN_689] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[689].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_689] = unsafe { *(result.output.as_ptr() as *const [G; OUT_689]) }; __ret } else { aiur_fn_689(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_689] = { let __args: [G; IN_689] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85]; let __cu = unconstrained; if let Some(result) = record.function_queries[689].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_689] = unsafe { *(result.output.as_ptr() as *const [G; OUT_689]) }; __ret } else { aiur_fn_689(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_689] = { let __args: [G; IN_689] = [__v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94]; let __cu = unconstrained; if let Some(result) = record.function_queries[689].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_689] = unsafe { *(result.output.as_ptr() as *const [G; OUT_689]) }; __ret } else { aiur_fn_689(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__v_43, __v_95, __v_96]; let __cu = unconstrained; if let Some(result) = record.function_queries[691].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_691] = unsafe { *(result.output.as_ptr() as *const [G; OUT_691]) }; __ret } else { aiur_fn_691(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_693] = { let __args: [G; IN_693] = [__v_44, __v_97, __v_98]; let __cu = unconstrained; if let Some(result) = record.function_queries[693].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_693] = unsafe { *(result.output.as_ptr() as *const [G; OUT_693]) }; __ret } else { aiur_fn_693(__args, record, io_buffer, __cu)? } };
+                let __ret: [G; OUT_697] = [];
+                record.function_queries[697].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                return Ok(__ret);
+              },
+            }
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_45.as_canonical_u64()));
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64()));
+      },
     }
-    let __ret: [G; OUT_764] = [];
-    record.function_queries[764].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-    return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_765: usize = 3;
-const IN_765: usize = 3;
-const OUT_765: usize = 0;
-fn aiur_fn_765(
-  inp: [G; IN_765],
+const INPUT_SIZE_698: usize = 2;
+const IN_698: usize = 2;
+const OUT_698: usize = 0;
+fn aiur_fn_698(
+  inp: [G; IN_698],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_765], ExecError> {
+) -> Result<[G; OUT_698], 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_757] = { let __args: [G; IN_757] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[757].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_757] = unsafe { *(result.output.as_ptr() as *const [G; OUT_757]) }; __ret } else { aiur_fn_757(__args, record, io_buffer, __cu)? } };
-    let __v_3: G = __r_arr[0];
-    let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[183].get_mut(&__args[..]) { 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_4: G = __r_arr[0];
-    let __v_5: G = __r_arr[1];
-    match __v_1.as_canonical_u64() {
+    let __loaded: [G; 64] = { let __mq = record.memory_queries.get_mut(&64).ok_or(ExecError::InvalidMemorySize(64))?; 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: 64 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 64] = __args[..64].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];
+    let __v_12: G = __loaded[10];
+    let __v_13: G = __loaded[11];
+    let __v_14: G = __loaded[12];
+    let __v_15: G = __loaded[13];
+    let __v_16: G = __loaded[14];
+    let __v_17: G = __loaded[15];
+    let __v_18: G = __loaded[16];
+    let __v_19: G = __loaded[17];
+    let __v_20: G = __loaded[18];
+    let __v_21: G = __loaded[19];
+    let __v_22: G = __loaded[20];
+    let __v_23: G = __loaded[21];
+    let __v_24: G = __loaded[22];
+    let __v_25: G = __loaded[23];
+    let __v_26: G = __loaded[24];
+    let __v_27: G = __loaded[25];
+    let __v_28: G = __loaded[26];
+    let __v_29: G = __loaded[27];
+    let __v_30: G = __loaded[28];
+    let __v_31: G = __loaded[29];
+    let __v_32: G = __loaded[30];
+    let __v_33: G = __loaded[31];
+    let __v_34: G = __loaded[32];
+    let __v_35: G = __loaded[33];
+    let __v_36: G = __loaded[34];
+    let __v_37: G = __loaded[35];
+    let __v_38: G = __loaded[36];
+    let __v_39: G = __loaded[37];
+    let __v_40: G = __loaded[38];
+    let __v_41: G = __loaded[39];
+    let __v_42: G = __loaded[40];
+    let __v_43: G = __loaded[41];
+    let __v_44: G = __loaded[42];
+    let __v_45: G = __loaded[43];
+    let __v_46: G = __loaded[44];
+    let __v_47: G = __loaded[45];
+    let __v_48: G = __loaded[46];
+    let __v_49: G = __loaded[47];
+    let __v_50: G = __loaded[48];
+    let __v_51: G = __loaded[49];
+    let __v_52: G = __loaded[50];
+    let __v_53: G = __loaded[51];
+    let __v_54: G = __loaded[52];
+    let __v_55: G = __loaded[53];
+    let __v_56: G = __loaded[54];
+    let __v_57: G = __loaded[55];
+    let __v_58: G = __loaded[56];
+    let __v_59: G = __loaded[57];
+    let __v_60: G = __loaded[58];
+    let __v_61: G = __loaded[59];
+    let __v_62: G = __loaded[60];
+    let __v_63: G = __loaded[61];
+    let __v_64: G = __loaded[62];
+    let __v_65: G = __loaded[63];
+    match __v_2.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_4, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_765] = [];
-        record.function_queries[765].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_698] = [];
+        record.function_queries[698].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_757] = { let __args: [G; IN_757] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[757].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_757] = unsafe { *(result.output.as_ptr() as *const [G; OUT_757]) }; __ret } else { aiur_fn_757(__args, record, io_buffer, __cu)? } };
-        let __v_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_761] = { let __args: [G; IN_761] = [__v_4, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[761].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_761] = unsafe { *(result.output.as_ptr() as *const [G; OUT_761]) }; __ret } else { aiur_fn_761(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_765] = [];
-        record.function_queries[765].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_0, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[715].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_715] = unsafe { *(result.output.as_ptr() as *const [G; OUT_715]) }; __ret } else { aiur_fn_715(__args, record, io_buffer, __cu)? } };
+        let __v_66: G = __r_arr[0];
+        let __v_67: G = __r_arr[1];
+        let __v_68: G = __r_arr[2];
+        let __v_69: G = __r_arr[3];
+        let __v_70: G = __r_arr[4];
+        let __v_71: G = __r_arr[5];
+        let __v_72: G = __r_arr[6];
+        let __v_73: G = __r_arr[7];
+        let __v_74: G = __r_arr[8];
+        let __v_75: G = __r_arr[9];
+        let __v_76: G = __r_arr[10];
+        let __v_77: G = __r_arr[11];
+        let __v_78: G = __r_arr[12];
+        let __v_79: G = __r_arr[13];
+        let __v_80: G = __r_arr[14];
+        let __v_81: G = __r_arr[15];
+        let __v_82: G = __r_arr[16];
+        let __v_83: G = __r_arr[17];
+        let __v_84: G = __r_arr[18];
+        let __v_85: G = __r_arr[19];
+        let __v_86: G = __r_arr[20];
+        let __v_87: G = __r_arr[21];
+        let __v_88: G = __r_arr[22];
+        let __v_89: G = __r_arr[23];
+        let __v_90: G = __r_arr[24];
+        let __v_91: G = __r_arr[25];
+        let __v_92: G = __r_arr[26];
+        let __v_93: G = __r_arr[27];
+        let __v_94: G = __r_arr[28];
+        let __v_95: G = __r_arr[29];
+        let __v_96: G = __r_arr[30];
+        let __v_97: G = __r_arr[31];
+        let __v_98: G = __r_arr[32];
+        let __v_99: G = __r_arr[33];
+        let __v_100: G = __r_arr[34];
+        let __v_101: G = __r_arr[35];
+        let __v_102: G = __r_arr[36];
+        let __v_103: G = __r_arr[37];
+        let __v_104: G = __r_arr[38];
+        let __v_105: G = __r_arr[39];
+        let __v_106: G = __r_arr[40];
+        let __v_107: G = __r_arr[41];
+        let __v_108: G = __r_arr[42];
+        let __v_109: G = __r_arr[43];
+        let __v_110: G = __r_arr[44];
+        let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__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_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]; let __cu = unconstrained; if let Some(result) = record.function_queries[697].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_697] = unsafe { *(result.output.as_ptr() as *const [G; OUT_697]) }; __ret } else { aiur_fn_697(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_0, __v_65]; let __cu = unconstrained; if let Some(result) = record.function_queries[698].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_698] = unsafe { *(result.output.as_ptr() as *const [G; OUT_698]) }; __ret } else { aiur_fn_698(__args, record, io_buffer, __cu)? } };
+        let __ret: [G; OUT_698] = [];
+        record.function_queries[698].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_766: usize = 55;
-const IN_766: usize = 55;
-const OUT_766: usize = 0;
-fn aiur_fn_766(
-  inp: [G; IN_766],
+const INPUT_SIZE_699: usize = 55;
+const IN_699: usize = 55;
+const OUT_699: usize = 0;
+fn aiur_fn_699(
+  inp: [G; IN_699],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_766], ExecError> {
+) -> Result<[G; OUT_699], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -64060,7 +57535,7 @@ fn aiur_fn_766(
     let __v_52: G = inp[52];
     let __v_53: G = inp[53];
     let __v_54: G = inp[54];
-    let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } else { aiur_fn_255(__args, record, io_buffer, __cu)? } };
     let __v_55: G = __r_arr[0];
     let __v_56: G = __r_arr[1];
     let __v_57: G = __r_arr[2];
@@ -64117,13 +57592,13 @@ fn aiur_fn_766(
               0u64 => {
                 match __v_56.as_canonical_u64() {
                   _ => {
-                    let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_56, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } else { aiur_fn_741(__args, record, io_buffer, __cu)? } };
-                    let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_57, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } else { aiur_fn_741(__args, record, io_buffer, __cu)? } };
-                    let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __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[744].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } else { aiur_fn_744(__args, record, io_buffer, __cu)? } };
-                    let __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_66, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[746].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_746] = unsafe { *(result.output.as_ptr() as *const [G; OUT_746]) }; __ret } else { aiur_fn_746(__args, record, io_buffer, __cu)? } };
-                    let __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_67, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[746].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_746] = unsafe { *(result.output.as_ptr() as *const [G; OUT_746]) }; __ret } else { aiur_fn_746(__args, record, io_buffer, __cu)? } };
-                    let __ret: [G; OUT_766] = [];
-                    record.function_queries[766].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __r_arr: [G; OUT_685] = { let __args: [G; IN_685] = [__v_56, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[685].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_685] = unsafe { *(result.output.as_ptr() as *const [G; OUT_685]) }; __ret } else { aiur_fn_685(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_686] = { let __args: [G; IN_686] = [__v_57, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[686].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_686] = unsafe { *(result.output.as_ptr() as *const [G; OUT_686]) }; __ret } else { aiur_fn_686(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_689] = { let __args: [G; IN_689] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __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[689].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_689] = unsafe { *(result.output.as_ptr() as *const [G; OUT_689]) }; __ret } else { aiur_fn_689(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__v_66, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[691].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_691] = unsafe { *(result.output.as_ptr() as *const [G; OUT_691]) }; __ret } else { aiur_fn_691(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__v_67, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[691].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_691] = unsafe { *(result.output.as_ptr() as *const [G; OUT_691]) }; __ret } else { aiur_fn_691(__args, record, io_buffer, __cu)? } };
+                    let __ret: [G; OUT_699] = [];
+                    record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
@@ -64138,17 +57613,17 @@ fn aiur_fn_766(
               1u64 => {
                 match __v_56.as_canonical_u64() {
                   _ => {
-                    let __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__v_56, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } else { aiur_fn_743(__args, record, io_buffer, __cu)? } };
-                    let __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__v_57, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } else { aiur_fn_743(__args, record, io_buffer, __cu)? } };
-                    let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __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[744].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } else { aiur_fn_744(__args, record, io_buffer, __cu)? } };
-                    let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } else { aiur_fn_744(__args, record, io_buffer, __cu)? } };
-                    let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __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[744].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } else { aiur_fn_744(__args, record, io_buffer, __cu)? } };
-                    let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } else { aiur_fn_744(__args, record, io_buffer, __cu)? } };
-                    let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } else { aiur_fn_744(__args, record, io_buffer, __cu)? } };
-                    let __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_98, __v_51, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[746].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_746] = unsafe { *(result.output.as_ptr() as *const [G; OUT_746]) }; __ret } else { aiur_fn_746(__args, record, io_buffer, __cu)? } };
-                    let __r_arr: [G; OUT_748] = { let __args: [G; IN_748] = [__v_99, __v_53, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[748].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_748] = unsafe { *(result.output.as_ptr() as *const [G; OUT_748]) }; __ret } else { aiur_fn_748(__args, record, io_buffer, __cu)? } };
-                    let __ret: [G; OUT_766] = [];
-                    record.function_queries[766].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __r_arr: [G; OUT_688] = { let __args: [G; IN_688] = [__v_56, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[688].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_688] = unsafe { *(result.output.as_ptr() as *const [G; OUT_688]) }; __ret } else { aiur_fn_688(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_688] = { let __args: [G; IN_688] = [__v_57, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[688].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_688] = unsafe { *(result.output.as_ptr() as *const [G; OUT_688]) }; __ret } else { aiur_fn_688(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_689] = { let __args: [G; IN_689] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __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[689].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_689] = unsafe { *(result.output.as_ptr() as *const [G; OUT_689]) }; __ret } else { aiur_fn_689(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_689] = { let __args: [G; IN_689] = [__v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[689].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_689] = unsafe { *(result.output.as_ptr() as *const [G; OUT_689]) }; __ret } else { aiur_fn_689(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_689] = { let __args: [G; IN_689] = [__v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __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[689].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_689] = unsafe { *(result.output.as_ptr() as *const [G; OUT_689]) }; __ret } else { aiur_fn_689(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_689] = { let __args: [G; IN_689] = [__v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[689].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_689] = unsafe { *(result.output.as_ptr() as *const [G; OUT_689]) }; __ret } else { aiur_fn_689(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_689] = { let __args: [G; IN_689] = [__v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[689].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_689] = unsafe { *(result.output.as_ptr() as *const [G; OUT_689]) }; __ret } else { aiur_fn_689(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__v_98, __v_51, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[691].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_691] = unsafe { *(result.output.as_ptr() as *const [G; OUT_691]) }; __ret } else { aiur_fn_691(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_693] = { let __args: [G; IN_693] = [__v_99, __v_53, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[693].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_693] = unsafe { *(result.output.as_ptr() as *const [G; OUT_693]) }; __ret } else { aiur_fn_693(__args, record, io_buffer, __cu)? } };
+                    let __ret: [G; OUT_699] = [];
+                    record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
@@ -64163,11 +57638,11 @@ fn aiur_fn_766(
               2u64 => {
                 match __v_56.as_canonical_u64() {
                   _ => {
-                    let __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__v_56, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } else { aiur_fn_743(__args, record, io_buffer, __cu)? } };
-                    let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_4, __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[744].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } else { aiur_fn_744(__args, record, io_buffer, __cu)? } };
-                    let __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_65, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[746].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_746] = unsafe { *(result.output.as_ptr() as *const [G; OUT_746]) }; __ret } else { aiur_fn_746(__args, record, io_buffer, __cu)? } };
-                    let __ret: [G; OUT_766] = [];
-                    record.function_queries[766].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __r_arr: [G; OUT_688] = { let __args: [G; IN_688] = [__v_56, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[688].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_688] = unsafe { *(result.output.as_ptr() as *const [G; OUT_688]) }; __ret } else { aiur_fn_688(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_689] = { let __args: [G; IN_689] = [__v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_4, __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[689].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_689] = unsafe { *(result.output.as_ptr() as *const [G; OUT_689]) }; __ret } else { aiur_fn_689(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__v_65, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[691].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_691] = unsafe { *(result.output.as_ptr() as *const [G; OUT_691]) }; __ret } else { aiur_fn_691(__args, record, io_buffer, __cu)? } };
+                    let __ret: [G; OUT_699] = [];
+                    record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
@@ -64182,11 +57657,11 @@ fn aiur_fn_766(
               3u64 => {
                 match __v_56.as_canonical_u64() {
                   _ => {
-                    let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_56, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } else { aiur_fn_742(__args, record, io_buffer, __cu)? } };
-                    let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_4, __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[744].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } else { aiur_fn_744(__args, record, io_buffer, __cu)? } };
-                    let __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_65, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[746].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_746] = unsafe { *(result.output.as_ptr() as *const [G; OUT_746]) }; __ret } else { aiur_fn_746(__args, record, io_buffer, __cu)? } };
-                    let __ret: [G; OUT_766] = [];
-                    record.function_queries[766].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __r_arr: [G; OUT_687] = { let __args: [G; IN_687] = [__v_56, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[687].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_687] = unsafe { *(result.output.as_ptr() as *const [G; OUT_687]) }; __ret } else { aiur_fn_687(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_689] = { let __args: [G; IN_689] = [__v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_4, __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[689].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_689] = unsafe { *(result.output.as_ptr() as *const [G; OUT_689]) }; __ret } else { aiur_fn_689(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__v_65, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[691].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_691] = unsafe { *(result.output.as_ptr() as *const [G; OUT_691]) }; __ret } else { aiur_fn_691(__args, record, io_buffer, __cu)? } };
+                    let __ret: [G; OUT_699] = [];
+                    record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
@@ -64201,11 +57676,11 @@ fn aiur_fn_766(
               4u64 => {
                 match __v_56.as_canonical_u64() {
                   _ => {
-                    let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } else { aiur_fn_744(__args, record, io_buffer, __cu)? } };
-                    let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_11, __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[744].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } else { aiur_fn_744(__args, record, io_buffer, __cu)? } };
-                    let __r_arr: [G; OUT_745] = { let __args: [G; IN_745] = [__v_72, __v_20, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[745].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_745] = unsafe { *(result.output.as_ptr() as *const [G; OUT_745]) }; __ret } else { aiur_fn_745(__args, record, io_buffer, __cu)? } };
-                    let __ret: [G; OUT_766] = [];
-                    record.function_queries[766].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __r_arr: [G; OUT_689] = { let __args: [G; IN_689] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[689].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_689] = unsafe { *(result.output.as_ptr() as *const [G; OUT_689]) }; __ret } else { aiur_fn_689(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_689] = { let __args: [G; IN_689] = [__v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_11, __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[689].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_689] = unsafe { *(result.output.as_ptr() as *const [G; OUT_689]) }; __ret } else { aiur_fn_689(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__v_72, __v_20, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[690].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_690] = unsafe { *(result.output.as_ptr() as *const [G; OUT_690]) }; __ret } else { aiur_fn_690(__args, record, io_buffer, __cu)? } };
+                    let __ret: [G; OUT_699] = [];
+                    record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
@@ -64220,10 +57695,10 @@ fn aiur_fn_766(
               5u64 => {
                 match __v_56.as_canonical_u64() {
                   _ => {
-                    let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } else { aiur_fn_744(__args, record, io_buffer, __cu)? } };
-                    let __r_arr: [G; OUT_745] = { let __args: [G; IN_745] = [__v_64, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[745].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_745] = unsafe { *(result.output.as_ptr() as *const [G; OUT_745]) }; __ret } else { aiur_fn_745(__args, record, io_buffer, __cu)? } };
-                    let __ret: [G; OUT_766] = [];
-                    record.function_queries[766].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __r_arr: [G; OUT_689] = { let __args: [G; IN_689] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[689].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_689] = unsafe { *(result.output.as_ptr() as *const [G; OUT_689]) }; __ret } else { aiur_fn_689(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__v_64, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[690].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_690] = unsafe { *(result.output.as_ptr() as *const [G; OUT_690]) }; __ret } else { aiur_fn_690(__args, record, io_buffer, __cu)? } };
+                    let __ret: [G; OUT_699] = [];
+                    record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
@@ -64238,10 +57713,10 @@ fn aiur_fn_766(
               6u64 => {
                 match __v_56.as_canonical_u64() {
                   _ => {
-                    let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } else { aiur_fn_744(__args, record, io_buffer, __cu)? } };
-                    let __r_arr: [G; OUT_745] = { let __args: [G; IN_745] = [__v_64, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[745].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_745] = unsafe { *(result.output.as_ptr() as *const [G; OUT_745]) }; __ret } else { aiur_fn_745(__args, record, io_buffer, __cu)? } };
-                    let __ret: [G; OUT_766] = [];
-                    record.function_queries[766].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __r_arr: [G; OUT_689] = { let __args: [G; IN_689] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[689].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_689] = unsafe { *(result.output.as_ptr() as *const [G; OUT_689]) }; __ret } else { aiur_fn_689(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__v_64, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[690].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_690] = unsafe { *(result.output.as_ptr() as *const [G; OUT_690]) }; __ret } else { aiur_fn_690(__args, record, io_buffer, __cu)? } };
+                    let __ret: [G; OUT_699] = [];
+                    record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
@@ -64256,10 +57731,10 @@ fn aiur_fn_766(
               7u64 => {
                 match __v_56.as_canonical_u64() {
                   _ => {
-                    let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } else { aiur_fn_744(__args, record, io_buffer, __cu)? } };
-                    let __r_arr: [G; OUT_745] = { let __args: [G; IN_745] = [__v_64, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[745].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_745] = unsafe { *(result.output.as_ptr() as *const [G; OUT_745]) }; __ret } else { aiur_fn_745(__args, record, io_buffer, __cu)? } };
-                    let __ret: [G; OUT_766] = [];
-                    record.function_queries[766].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __r_arr: [G; OUT_689] = { let __args: [G; IN_689] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[689].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_689] = unsafe { *(result.output.as_ptr() as *const [G; OUT_689]) }; __ret } else { aiur_fn_689(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__v_64, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[690].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_690] = unsafe { *(result.output.as_ptr() as *const [G; OUT_690]) }; __ret } else { aiur_fn_690(__args, record, io_buffer, __cu)? } };
+                    let __ret: [G; OUT_699] = [];
+                    record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
@@ -64272,9 +57747,9 @@ fn aiur_fn_766(
           8u64 => {
             match __v_1.as_canonical_u64() {
               8u64 => {
-                let __r_arr: [G; OUT_753] = { let __args: [G; IN_753] = [__v_56, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[753].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_753] = unsafe { *(result.output.as_ptr() as *const [G; OUT_753]) }; __ret } else { aiur_fn_753(__args, record, io_buffer, __cu)? } };
-                let __ret: [G; OUT_766] = [];
-                record.function_queries[766].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_56, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[698].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_698] = unsafe { *(result.output.as_ptr() as *const [G; OUT_698]) }; __ret } else { aiur_fn_698(__args, record, io_buffer, __cu)? } };
+                let __ret: [G; OUT_699] = [];
+                record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
@@ -64291,40 +57766,41 @@ fn aiur_fn_766(
   })
 }
 
-const INPUT_SIZE_767: usize = 4;
-const IN_767: usize = 4;
-const OUT_767: usize = 0;
-fn aiur_fn_767(
-  inp: [G; IN_767],
+const INPUT_SIZE_700: usize = 2;
+const IN_700: usize = 2;
+const OUT_700: usize = 0;
+fn aiur_fn_700(
+  inp: [G; IN_700],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_767], ExecError> {
+) -> Result<[G; OUT_700], 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(0);
-    let __v_5: G = G::from_u64(1);
-    if (__v_4 != __v_5) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_4.as_canonical_u64(), rhs: __v_5.as_canonical_u64() });
+    let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } };
+    let __v_2: G = __r_arr[0];
+    let __r_arr: [G; OUT_376] = { let __args: [G; IN_376] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[376].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_376] = unsafe { *(result.output.as_ptr() as *const [G; OUT_376]) }; __ret } else { aiur_fn_376(__args, record, io_buffer, __cu)? } };
+    let __v_3: G = __r_arr[0];
+    let __v_4: G = G::from_u64(1);
+    if (__v_3 != __v_4) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("Contains: target is not a leaf of the claimed tree".to_string()) });
     }
-    let __ret: [G; OUT_767] = [];
-    record.function_queries[767].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __ret: [G; OUT_700] = [];
+    record.function_queries[700].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_768: usize = 32;
-const IN_768: usize = 32;
-const OUT_768: usize = 0;
-fn aiur_fn_768(
-  inp: [G; IN_768],
+const INPUT_SIZE_701: usize = 32;
+const IN_701: usize = 32;
+const OUT_701: usize = 0;
+fn aiur_fn_701(
+  inp: [G; IN_701],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_768], ExecError> {
+) -> Result<[G; OUT_701], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -64358,110 +57834,186 @@ fn aiur_fn_768(
     let __v_29: G = inp[29];
     let __v_30: G = inp[30];
     let __v_31: G = inp[31];
-    let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__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]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } else { aiur_fn_738(__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 __v_42: G = __r_arr[10];
-    let __v_43: G = __r_arr[11];
-    let __v_44: G = __r_arr[12];
-    let __v_45: G = __r_arr[13];
-    let __v_46: G = __r_arr[14];
-    let __v_47: G = __r_arr[15];
-    let __v_48: G = __r_arr[16];
-    let __v_49: G = __r_arr[17];
-    let __v_50: G = __r_arr[18];
-    let __v_51: G = __r_arr[19];
-    let __v_52: G = __r_arr[20];
-    let __v_53: G = __r_arr[21];
-    let __v_54: G = __r_arr[22];
-    let __v_55: G = __r_arr[23];
-    let __v_56: G = __r_arr[24];
-    let __v_57: G = __r_arr[25];
-    let __v_58: G = __r_arr[26];
-    let __v_59: G = __r_arr[27];
-    let __v_60: G = __r_arr[28];
-    let __v_61: G = __r_arr[29];
-    let __v_62: G = __r_arr[30];
-    let __v_63: G = __r_arr[31];
-    let __v_64: G = __r_arr[32];
-    let __v_65: G = __r_arr[33];
-    let __v_66: G = __r_arr[34];
-    let __v_67: G = __r_arr[35];
-    let __v_68: G = __r_arr[36];
-    let __v_69: G = __r_arr[37];
-    let __v_70: G = __r_arr[38];
-    let __v_71: G = __r_arr[39];
-    let __v_72: G = __r_arr[40];
-    let __v_73: G = __r_arr[41];
-    let __v_74: G = __r_arr[42];
-    let __v_75: G = __r_arr[43];
-    let __v_76: G = __r_arr[44];
-    let __v_77: G = __r_arr[45];
-    let __v_78: G = __r_arr[46];
-    let __v_79: G = __r_arr[47];
-    let __v_80: G = __r_arr[48];
-    let __v_81: G = __r_arr[49];
-    let __v_82: G = __r_arr[50];
-    let __v_83: G = __r_arr[51];
-    let __v_84: G = __r_arr[52];
-    let __v_85: G = __r_arr[53];
-    let __v_86: G = __r_arr[54];
-    let __v_87: G = __r_arr[55];
-    match __v_32.as_canonical_u64() {
-      0u64 => {
-        let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_33, __v_34, __v_35, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_768] = [];
-        record.function_queries[768].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      1u64 => {
-        let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_33, __v_34, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } else { aiur_fn_763(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_768] = [];
-        record.function_queries[768].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
+    let __v_32: G = G::from_u64(0);
+    let __io_pair: (G, G) = { let __key: [G; 32] = [__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]; let __info = io_buffer.get_info(__v_32, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) };
+    let __v_33: G = __io_pair.0;
+    let __v_34: G = __io_pair.1;
+    let __v_35: G = G::from_u64(0);
+    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_35, __v_33, __v_34]; let __cu = true; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
+    let __v_36: G = __r_arr[0];
+    let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_36, __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]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } else { aiur_fn_17(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } else { aiur_fn_72(__args, record, io_buffer, __cu)? } };
+    let __v_37: G = __r_arr[0];
+    let __v_38: G = __r_arr[1];
+    let __v_39: G = __r_arr[2];
+    let __v_40: G = __r_arr[3];
+    let __v_41: G = __r_arr[4];
+    let __v_42: G = __r_arr[5];
+    let __v_43: G = __r_arr[6];
+    let __v_44: G = __r_arr[7];
+    let __v_45: G = __r_arr[8];
+    let __v_46: G = __r_arr[9];
+    let __v_47: G = G::from_u64(14);
+    if (__v_37 != __v_47) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_37.as_canonical_u64(), rhs: __v_47.as_canonical_u64(), msg: Some("claim: wrong tag4 flag".to_string()) });
+    }
+    let __v_48: G = (__v_39 + __v_40);
+    let __v_49: G = (__v_48 + __v_41);
+    let __v_50: G = (__v_49 + __v_42);
+    let __v_51: G = (__v_50 + __v_43);
+    let __v_52: G = (__v_51 + __v_44);
+    let __v_53: G = (__v_52 + __v_45);
+    let __v_54: G = G::from_u64(0);
+    if (__v_53 != __v_54) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_53.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: Some("claim: tag4 size exceeds a single byte".to_string()) });
+    }
+    match __v_38.as_canonical_u64() {
+      4u64 => {
+        let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[81].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_81] = unsafe { *(result.output.as_ptr() as *const [G; OUT_81]) }; __ret } else { aiur_fn_81(__args, record, io_buffer, __cu)? } };
+        let __v_55: G = __r_arr[0];
+        let __v_56: G = __r_arr[1];
+        let __r_arr: [G; OUT_667] = { let __args: [G; IN_667] = [__v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[667].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_667] = unsafe { *(result.output.as_ptr() as *const [G; OUT_667]) }; __ret } else { aiur_fn_667(__args, record, io_buffer, __cu)? } };
+        let __v_57: G = __r_arr[0];
+        let __v_58: G = __r_arr[1];
+        let __v_59: G = __r_arr[2];
+        match __v_57.as_canonical_u64() {
+          1u64 => {
+            let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[653].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_653] = unsafe { *(result.output.as_ptr() as *const [G; OUT_653]) }; __ret } else { aiur_fn_653(__args, record, io_buffer, __cu)? } };
+            let __ret: [G; OUT_701] = [];
+            record.function_queries[701].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          0u64 => {
+            let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } };
+            let __v_60: G = __r_arr[0];
+            let __v_61: G = G::from_u64(1);
+            let __v_62: G = G::from_u64(1);
+            let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_60, __v_61, __v_62, __v_62, __v_62, __v_62, __v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[661].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_661] = unsafe { *(result.output.as_ptr() as *const [G; OUT_661]) }; __ret } else { aiur_fn_661(__args, record, io_buffer, __cu)? } };
+            let __v_63: G = __r_arr[0];
+            let __v_64: G = __r_arr[1];
+            let __v_65: G = __r_arr[2];
+            let __v_66: G = __r_arr[3];
+            let __v_67: G = __r_arr[4];
+            let __v_68: G = __r_arr[5];
+            let __v_69: G = G::from_u64(1);
+            let __v_70: G = G::from_u64(1);
+            let __v_71: G = G::from_u64(0);
+            let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_55, __v_69, __v_70, __v_70, __v_70, __v_70, __v_70, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_71]; let __cu = unconstrained; if let Some(result) = record.function_queries[663].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_663] = unsafe { *(result.output.as_ptr() as *const [G; OUT_663]) }; __ret } else { aiur_fn_663(__args, record, io_buffer, __cu)? } };
+            let __ret: [G; OUT_701] = [];
+            record.function_queries[701].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            return Ok(__ret);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_57.as_canonical_u64()));
+          },
+        }
       },
-      2u64 => {
-        let __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_33, __v_34, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[765].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_765] = unsafe { *(result.output.as_ptr() as *const [G; OUT_765]) }; __ret } else { aiur_fn_765(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_768] = [];
-        record.function_queries[768].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+      5u64 => {
+        let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[81].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_81] = unsafe { *(result.output.as_ptr() as *const [G; OUT_81]) }; __ret } else { aiur_fn_81(__args, record, io_buffer, __cu)? } };
+        let __v_55: G = __r_arr[0];
+        let __v_56: G = __r_arr[1];
+        let __r_arr: [G; OUT_667] = { let __args: [G; IN_667] = [__v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[667].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_667] = unsafe { *(result.output.as_ptr() as *const [G; OUT_667]) }; __ret } else { aiur_fn_667(__args, record, io_buffer, __cu)? } };
+        let __v_57: G = __r_arr[0];
+        let __v_58: G = __r_arr[1];
+        let __v_59: G = __r_arr[2];
+        let __r_arr: [G; OUT_666] = { let __args: [G; IN_666] = [__v_55, __v_57, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[666].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_666] = unsafe { *(result.output.as_ptr() as *const [G; OUT_666]) }; __ret } else { aiur_fn_666(__args, record, io_buffer, __cu)? } };
+        let __ret: [G; OUT_701] = [];
+        record.function_queries[701].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      3u64 => {
-        let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__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]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } else { aiur_fn_766(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_768] = [];
-        record.function_queries[768].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+      6u64 => {
+        let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[81].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_81] = unsafe { *(result.output.as_ptr() as *const [G; OUT_81]) }; __ret } else { aiur_fn_81(__args, record, io_buffer, __cu)? } };
+        let __v_55: G = __r_arr[0];
+        let __v_56: G = __r_arr[1];
+        let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[682].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_682] = unsafe { *(result.output.as_ptr() as *const [G; OUT_682]) }; __ret } else { aiur_fn_682(__args, record, io_buffer, __cu)? } };
+        let __v_57: G = __r_arr[0];
+        let __v_58: G = __r_arr[1];
+        let __v_59: G = __r_arr[2];
+        let __v_60: G = __r_arr[3];
+        let __v_61: G = __r_arr[4];
+        let __v_62: G = __r_arr[5];
+        let __v_63: G = __r_arr[6];
+        let __v_64: G = __r_arr[7];
+        let __v_65: G = __r_arr[8];
+        let __v_66: G = __r_arr[9];
+        let __v_67: G = __r_arr[10];
+        let __v_68: G = __r_arr[11];
+        let __v_69: G = __r_arr[12];
+        let __v_70: G = __r_arr[13];
+        let __v_71: G = __r_arr[14];
+        let __v_72: G = __r_arr[15];
+        let __v_73: G = __r_arr[16];
+        let __v_74: G = __r_arr[17];
+        let __v_75: G = __r_arr[18];
+        let __v_76: G = __r_arr[19];
+        let __v_77: G = __r_arr[20];
+        let __v_78: G = __r_arr[21];
+        let __v_79: G = __r_arr[22];
+        let __v_80: G = __r_arr[23];
+        let __v_81: G = __r_arr[24];
+        let __v_82: G = __r_arr[25];
+        let __v_83: G = __r_arr[26];
+        let __v_84: G = __r_arr[27];
+        let __v_85: G = __r_arr[28];
+        let __v_86: G = __r_arr[29];
+        let __v_87: G = __r_arr[30];
+        let __v_88: G = __r_arr[31];
+        let __v_89: G = __r_arr[32];
+        let __v_90: G = __r_arr[33];
+        let __v_91: G = __r_arr[34];
+        let __v_92: G = __r_arr[35];
+        let __v_93: G = __r_arr[36];
+        let __v_94: G = __r_arr[37];
+        let __v_95: G = __r_arr[38];
+        let __v_96: G = __r_arr[39];
+        let __v_97: G = __r_arr[40];
+        let __v_98: G = __r_arr[41];
+        let __v_99: G = __r_arr[42];
+        let __v_100: G = __r_arr[43];
+        let __v_101: G = __r_arr[44];
+        let __v_102: G = __r_arr[45];
+        let __v_103: G = __r_arr[46];
+        let __v_104: G = __r_arr[47];
+        let __v_105: G = __r_arr[48];
+        let __v_106: G = __r_arr[49];
+        let __v_107: G = __r_arr[50];
+        let __v_108: G = __r_arr[51];
+        let __v_109: G = __r_arr[52];
+        let __v_110: G = __r_arr[53];
+        let __v_111: G = __r_arr[54];
+        let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_55, __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]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } else { aiur_fn_699(__args, record, io_buffer, __cu)? } };
+        let __ret: [G; OUT_701] = [];
+        record.function_queries[701].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      4u64 => {
-        let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_33, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } else { aiur_fn_764(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_768] = [];
-        record.function_queries[768].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+      7u64 => {
+        let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[81].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_81] = unsafe { *(result.output.as_ptr() as *const [G; OUT_81]) }; __ret } else { aiur_fn_81(__args, record, io_buffer, __cu)? } };
+        let __v_55: G = __r_arr[0];
+        let __v_56: G = __r_arr[1];
+        let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[81].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_81] = unsafe { *(result.output.as_ptr() as *const [G; OUT_81]) }; __ret } else { aiur_fn_81(__args, record, io_buffer, __cu)? } };
+        let __v_57: G = __r_arr[0];
+        let __v_58: G = __r_arr[1];
+        let __r_arr: [G; OUT_700] = { let __args: [G; IN_700] = [__v_55, __v_57]; let __cu = unconstrained; if let Some(result) = record.function_queries[700].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_700] = unsafe { *(result.output.as_ptr() as *const [G; OUT_700]) }; __ret } else { aiur_fn_700(__args, record, io_buffer, __cu)? } };
+        let __ret: [G; OUT_701] = [];
+        record.function_queries[701].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_32.as_canonical_u64()));
+        return Err(ExecError::MatchNoCase(__v_38.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_769: usize = 32;
-const IN_769: usize = 32;
-const OUT_769: usize = 0;
-fn aiur_fn_769(
-  inp: [G; IN_769],
+const INPUT_SIZE_702: usize = 32;
+const IN_702: usize = 32;
+const OUT_702: usize = 0;
+fn aiur_fn_702(
+  inp: [G; IN_702],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_769], ExecError> {
+) -> Result<[G; OUT_702], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -64495,43 +58047,59 @@ fn aiur_fn_769(
     let __v_29: G = inp[29];
     let __v_30: G = inp[30];
     let __v_31: G = inp[31];
-    let __v_32: G = { let __values: [G; 32] = [__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]; 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_182] = { let __args: [G; IN_182] = [__v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[182].get_mut(&__args[..]) { 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_33: G = __r_arr[0];
-    let __v_34: G = __r_arr[1];
-    let __v_35: G = G::from_u64(0);
-    let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_32, __v_34, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[480].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_480] = unsafe { *(result.output.as_ptr() as *const [G; OUT_480]) }; __ret } else { aiur_fn_480(__args, record, io_buffer, __cu)? } };
-    let __v_36: G = __r_arr[0];
-    let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_33, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
-    let __v_37: G = __r_arr[0];
-    let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_37.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr };
-    let __v_38: G = __loaded[0];
-    let __v_39: G = __loaded[1];
-    let __v_40: G = __loaded[2];
-    let __v_41: G = __loaded[3];
-    let __v_42: G = __loaded[4];
-    let __v_43: G = __loaded[5];
-    let __v_44: G = __loaded[6];
-    let __v_45: G = __loaded[7];
-    let __v_46: G = __loaded[8];
-    let __v_47: G = __loaded[9];
-    let __v_48: G = __loaded[10];
-    let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_36, __v_33, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } };
-    let __ret: [G; OUT_769] = [];
-    record.function_queries[769].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __r_arr: [G; OUT_701] = { let __args: [G; IN_701] = [__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]; let __cu = unconstrained; if let Some(result) = record.function_queries[701].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_701] = unsafe { *(result.output.as_ptr() as *const [G; OUT_701]) }; __ret } else { aiur_fn_701(__args, record, io_buffer, __cu)? } };
+    let __ret: [G; OUT_702] = [];
+    record.function_queries[702].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_770: usize = 2;
-const IN_770: usize = 2;
-const OUT_770: usize = 1;
-fn aiur_fn_770(
-  inp: [G; IN_770],
+const INPUT_SIZE_703: usize = 3;
+const IN_703: usize = 3;
+const OUT_703: usize = 1;
+fn aiur_fn_703(
+  inp: [G; IN_703],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_703], 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_722] = { let __args: [G; IN_722] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } };
+    let __v_3: 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_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() {
+      1u64 => {
+        let __ret: [G; OUT_703] = [__v_2];
+        record.function_queries[703].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __ret: [G; OUT_703] = [__v_5];
+        record.function_queries[703].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_704: usize = 2;
+const IN_704: usize = 2;
+const OUT_704: usize = 1;
+fn aiur_fn_704(
+  inp: [G; IN_704],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_770], ExecError> {
+) -> Result<[G; OUT_704], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -64546,17 +58114,17 @@ fn aiur_fn_770(
         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 __v_9: G = { let __values: [G; 3] = [__v_5, __v_1, __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_770] = [__v_9];
-        record.function_queries[770].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_704] = [__v_9];
+        record.function_queries[704].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         let __v_5: G = G::from_u64(0);
-        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_704] = { let __args: [G; IN_704] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[704].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_704] = unsafe { *(result.output.as_ptr() as *const [G; OUT_704]) }; __ret } else { aiur_fn_704(__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_770] = [__v_7];
-        record.function_queries[770].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_704] = [__v_7];
+        record.function_queries[704].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -64566,15 +58134,15 @@ fn aiur_fn_770(
   })
 }
 
-const INPUT_SIZE_771: usize = 1;
-const IN_771: usize = 1;
-const OUT_771: usize = 8;
-fn aiur_fn_771(
-  inp: [G; IN_771],
+const INPUT_SIZE_705: usize = 1;
+const IN_705: usize = 1;
+const OUT_705: usize = 8;
+fn aiur_fn_705(
+  inp: [G; IN_705],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_771], ExecError> {
+) -> Result<[G; OUT_705], 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 };
@@ -64598,12 +58166,12 @@ fn aiur_fn_771(
         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 __ret: [G; OUT_771] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18];
-        record.function_queries[771].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_705] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18];
+        record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } else { aiur_fn_771(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_705] = { let __args: [G; IN_705] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[705].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_705] = unsafe { *(result.output.as_ptr() as *const [G; OUT_705]) }; __ret } else { aiur_fn_705(__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];
@@ -64612,7 +58180,7 @@ fn aiur_fn_771(
         let __v_16: G = __r_arr[5];
         let __v_17: G = __r_arr[6];
         let __v_18: G = __r_arr[7];
-        let __r_arr: [G; OUT_11] = { let __args: [G; IN_11] = [__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[11].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_11] = unsafe { *(result.output.as_ptr() as *const [G; OUT_11]) }; __ret } else { aiur_fn_11(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__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[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__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];
@@ -64621,8 +58189,8 @@ fn aiur_fn_771(
         let __v_24: G = __r_arr[5];
         let __v_25: G = __r_arr[6];
         let __v_26: G = __r_arr[7];
-        let __ret: [G; OUT_771] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26];
-        record.function_queries[771].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_705] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26];
+        record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -64632,15 +58200,54 @@ fn aiur_fn_771(
   })
 }
 
-const INPUT_SIZE_772: usize = 1;
-const IN_772: usize = 1;
-const OUT_772: usize = 8;
-fn aiur_fn_772(
-  inp: [G; IN_772],
+const INPUT_SIZE_706: usize = 2;
+const IN_706: usize = 2;
+const OUT_706: usize = 1;
+fn aiur_fn_706(
+  inp: [G; IN_706],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_706], 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_706] = [__v_1];
+        record.function_queries[706].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __v_6: G = G::from_u64(0);
+        let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[706].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_706] = unsafe { *(result.output.as_ptr() as *const [G; OUT_706]) }; __ret } else { aiur_fn_706(__args, record, io_buffer, __cu)? } };
+        let __v_7: G = __r_arr[0];
+        let __v_8: G = { let __values: [G; 4] = [__v_6, __v_3, __v_4, __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_706] = [__v_8];
+        record.function_queries[706].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_707: usize = 1;
+const IN_707: usize = 1;
+const OUT_707: usize = 8;
+fn aiur_fn_707(
+  inp: [G; IN_707],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_772], ExecError> {
+) -> Result<[G; OUT_707], 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 };
@@ -64657,12 +58264,12 @@ fn aiur_fn_772(
         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 __ret: [G; OUT_772] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11];
-        record.function_queries[772].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_707] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11];
+        record.function_queries[707].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[772].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_772] = unsafe { *(result.output.as_ptr() as *const [G; OUT_772]) }; __ret } else { aiur_fn_772(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_707] = { let __args: [G; IN_707] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[707].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_707] = unsafe { *(result.output.as_ptr() as *const [G; OUT_707]) }; __ret } else { aiur_fn_707(__args, record, io_buffer, __cu)? } };
         let __v_4: G = __r_arr[0];
         let __v_5: G = __r_arr[1];
         let __v_6: G = __r_arr[2];
@@ -64671,7 +58278,7 @@ fn aiur_fn_772(
         let __v_9: G = __r_arr[5];
         let __v_10: G = __r_arr[6];
         let __v_11: G = __r_arr[7];
-        let __r_arr: [G; OUT_11] = { let __args: [G; IN_11] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[11].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_11] = unsafe { *(result.output.as_ptr() as *const [G; OUT_11]) }; __ret } else { aiur_fn_11(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__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];
@@ -64680,8 +58287,8 @@ fn aiur_fn_772(
         let __v_17: G = __r_arr[5];
         let __v_18: G = __r_arr[6];
         let __v_19: G = __r_arr[7];
-        let __ret: [G; OUT_772] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19];
-        record.function_queries[772].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_707] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19];
+        record.function_queries[707].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -64691,53 +58298,15 @@ fn aiur_fn_772(
   })
 }
 
-const INPUT_SIZE_773: usize = 2;
-const IN_773: usize = 2;
-const OUT_773: usize = 1;
-fn aiur_fn_773(
-  inp: [G; IN_773],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_773], 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_773] = [__v_1];
-        record.function_queries[773].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __v_5: G = G::from_u64(0);
-        let __r_arr: [G; OUT_773] = { let __args: [G; IN_773] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[773].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_773] = unsafe { *(result.output.as_ptr() as *const [G; OUT_773]) }; __ret } else { aiur_fn_773(__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_773] = [__v_7];
-        record.function_queries[773].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_774: usize = 8;
-const IN_774: usize = 8;
-const OUT_774: usize = 1;
-fn aiur_fn_774(
-  inp: [G; IN_774],
+const INPUT_SIZE_708: usize = 8;
+const IN_708: usize = 8;
+const OUT_708: usize = 1;
+fn aiur_fn_708(
+  inp: [G; IN_708],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_774], ExecError> {
+) -> Result<[G; OUT_708], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -64749,8 +58318,8 @@ fn aiur_fn_774(
     let __v_7: G = inp[7];
     match __v_1.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_774] = [__v_7];
-        record.function_queries[774].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_708] = [__v_7];
+        record.function_queries[708].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -64771,25 +58340,25 @@ fn aiur_fn_774(
         let __v_20: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_3.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_20.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_0, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[774].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } else { aiur_fn_774(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_708] = { let __args: [G; IN_708] = [__v_0, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[708].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_708] = unsafe { *(result.output.as_ptr() as *const [G; OUT_708]) }; __ret } else { aiur_fn_708(__args, record, io_buffer, __cu)? } };
             let __v_21: G = __r_arr[0];
-            let __ret: [G; OUT_774] = [__v_21];
-            record.function_queries[774].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_708] = [__v_21];
+            record.function_queries[708].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
             let __v_21: G = (__v_0 - __v_3);
             match __v_21.as_canonical_u64() {
               0u64 => {
-                let __ret: [G; OUT_774] = [__v_4];
-                record.function_queries[774].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_708] = [__v_4];
+                record.function_queries[708].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_0, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[774].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } else { aiur_fn_774(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_708] = { let __args: [G; IN_708] = [__v_0, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[708].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_708] = unsafe { *(result.output.as_ptr() as *const [G; OUT_708]) }; __ret } else { aiur_fn_708(__args, record, io_buffer, __cu)? } };
                 let __v_22: G = __r_arr[0];
-                let __ret: [G; OUT_774] = [__v_22];
-                record.function_queries[774].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_708] = [__v_22];
+                record.function_queries[708].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -64803,37 +58372,57 @@ fn aiur_fn_774(
   })
 }
 
-const INPUT_SIZE_775: usize = 2;
-const IN_775: usize = 2;
-const OUT_775: usize = 1;
-fn aiur_fn_775(
-  inp: [G; IN_775],
+const INPUT_SIZE_709: usize = 1;
+const IN_709: usize = 1;
+const OUT_709: usize = 1;
+fn aiur_fn_709(
+  inp: [G; IN_709],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_709], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = G::from_u64(1);
+    let __v_2: G = G::from_u64(1);
+    let __v_3: G = { let __values: [G; 3] = [__v_1, __v_2, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_727] = { let __args: [G; IN_727] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[727].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_727] = unsafe { *(result.output.as_ptr() as *const [G; OUT_727]) }; __ret } else { aiur_fn_727(__args, record, io_buffer, __cu)? } };
+    let __v_4: G = __r_arr[0];
+    let __ret: [G; OUT_709] = [__v_4];
+    record.function_queries[709].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_710: usize = 2;
+const IN_710: usize = 2;
+const OUT_710: usize = 1;
+fn aiur_fn_710(
+  inp: [G; IN_710],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_775], ExecError> {
+) -> Result<[G; OUT_710], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    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 };
+    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];
-    let __v_5: G = __loaded[3];
-    let __v_6: G = __loaded[4];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_775] = [__v_1];
-        record.function_queries[775].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_710] = [__v_1];
+        record.function_queries[710].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __v_7: G = G::from_u64(0);
-        let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } else { aiur_fn_775(__args, record, io_buffer, __cu)? } };
-        let __v_8: G = __r_arr[0];
-        let __v_9: G = { let __values: [G; 5] = [__v_7, __v_3, __v_4, __v_5, __v_8]; 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_775] = [__v_9];
-        record.function_queries[775].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __v_5: G = G::from_u64(0);
+        let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[710].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_710] = unsafe { *(result.output.as_ptr() as *const [G; OUT_710]) }; __ret } else { aiur_fn_710(__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_710] = [__v_7];
+        record.function_queries[710].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -64843,37 +58432,53 @@ fn aiur_fn_775(
   })
 }
 
-const INPUT_SIZE_776: usize = 1;
-const IN_776: usize = 1;
-const OUT_776: usize = 1;
-fn aiur_fn_776(
-  inp: [G; IN_776],
+const INPUT_SIZE_711: usize = 1;
+const IN_711: usize = 1;
+const OUT_711: usize = 1;
+fn aiur_fn_711(
+  inp: [G; IN_711],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_776], ExecError> {
+) -> Result<[G; OUT_711], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __v_1: G = G::from_u64(1);
-    let __v_2: G = G::from_u64(1);
-    let __v_3: G = { let __values: [G; 3] = [__v_1, __v_2, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.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_799] = { let __args: [G; IN_799] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[799].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_799] = unsafe { *(result.output.as_ptr() as *const [G; OUT_799]) }; __ret } else { aiur_fn_799(__args, record, io_buffer, __cu)? } };
-    let __v_4: G = __r_arr[0];
-    let __ret: [G; OUT_776] = [__v_4];
-    record.function_queries[776].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_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_711] = [__v_4];
+        record.function_queries[711].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } else { aiur_fn_711(__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_711] = [__v_6];
+        record.function_queries[711].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+      },
+    }
   })
 }
 
-const INPUT_SIZE_777: usize = 1;
-const IN_777: usize = 1;
-const OUT_777: usize = 8;
-fn aiur_fn_777(
-  inp: [G; IN_777],
+const INPUT_SIZE_712: usize = 1;
+const IN_712: usize = 1;
+const OUT_712: usize = 8;
+fn aiur_fn_712(
+  inp: [G; IN_712],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_777], ExecError> {
+) -> Result<[G; OUT_712], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __loaded: [G; 36] = { let __mq = record.memory_queries.get_mut(&36).ok_or(ExecError::InvalidMemorySize(36))?; 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: 36 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 36] = __args[..36].try_into().unwrap(); __arr };
@@ -64923,12 +58528,12 @@ fn aiur_fn_777(
         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 __ret: [G; OUT_777] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44];
-        record.function_queries[777].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_712] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44];
+        record.function_queries[712].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[777].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_777] = unsafe { *(result.output.as_ptr() as *const [G; OUT_777]) }; __ret } else { aiur_fn_777(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[712].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_712] = unsafe { *(result.output.as_ptr() as *const [G; OUT_712]) }; __ret } else { aiur_fn_712(__args, record, io_buffer, __cu)? } };
         let __v_37: G = __r_arr[0];
         let __v_38: G = __r_arr[1];
         let __v_39: G = __r_arr[2];
@@ -64937,7 +58542,7 @@ fn aiur_fn_777(
         let __v_42: G = __r_arr[5];
         let __v_43: G = __r_arr[6];
         let __v_44: G = __r_arr[7];
-        let __r_arr: [G; OUT_11] = { let __args: [G; IN_11] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[11].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_11] = unsafe { *(result.output.as_ptr() as *const [G; OUT_11]) }; __ret } else { aiur_fn_11(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } };
         let __v_45: G = __r_arr[0];
         let __v_46: G = __r_arr[1];
         let __v_47: G = __r_arr[2];
@@ -64946,8 +58551,8 @@ fn aiur_fn_777(
         let __v_50: G = __r_arr[5];
         let __v_51: G = __r_arr[6];
         let __v_52: G = __r_arr[7];
-        let __ret: [G; OUT_777] = [__v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52];
-        record.function_queries[777].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_712] = [__v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52];
+        record.function_queries[712].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -64957,19 +58562,19 @@ fn aiur_fn_777(
   })
 }
 
-const INPUT_SIZE_778: usize = 2;
-const IN_778: usize = 2;
-const OUT_778: usize = 1;
-fn aiur_fn_778(
-  inp: [G; IN_778],
+const INPUT_SIZE_713: usize = 2;
+const IN_713: usize = 2;
+const OUT_713: usize = 1;
+fn aiur_fn_713(
+  inp: [G; IN_713],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_778], ExecError> {
+) -> Result<[G; OUT_713], 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_796] = { let __args: [G; IN_796] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[796].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_796] = unsafe { *(result.output.as_ptr() as *const [G; OUT_796]) }; __ret } else { aiur_fn_796(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__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];
@@ -64977,8 +58582,8 @@ fn aiur_fn_778(
     let __v_5: G = __loaded[2];
     match __v_3.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_778] = [__v_4];
-        record.function_queries[778].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_713] = [__v_4];
+        record.function_queries[713].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -64988,76 +58593,15 @@ fn aiur_fn_778(
   })
 }
 
-const INPUT_SIZE_779: usize = 9;
-const IN_779: usize = 9;
-const OUT_779: usize = 1;
-fn aiur_fn_779(
-  inp: [G; IN_779],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_779], 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; 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_9: G = __loaded[0];
-    let __v_10: G = __loaded[1];
-    let __v_11: G = __loaded[2];
-    match __v_9.as_canonical_u64() {
-      0u64 => {
-        let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__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[2].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
-        let __v_12: G = __r_arr[0];
-        match __v_12.as_canonical_u64() {
-          1u64 => {
-            let __ret: [G; OUT_779] = [__v_10];
-            record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          0u64 => {
-            let __r_arr: [G; OUT_12] = { let __args: [G; IN_12] = [__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[12].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_12] = unsafe { *(result.output.as_ptr() as *const [G; OUT_12]) }; __ret } else { aiur_fn_12(__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 __r_arr: [G; OUT_779] = { let __args: [G; IN_779] = [__v_11, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[779].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_779] = unsafe { *(result.output.as_ptr() as *const [G; OUT_779]) }; __ret } else { aiur_fn_779(__args, record, io_buffer, __cu)? } };
-            let __v_21: G = __r_arr[0];
-            let __ret: [G; OUT_779] = [__v_21];
-            record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64()));
-          },
-        }
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_780: usize = 1;
-const IN_780: usize = 1;
-const OUT_780: usize = 1;
-fn aiur_fn_780(
-  inp: [G; IN_780],
+const INPUT_SIZE_714: usize = 1;
+const IN_714: usize = 1;
+const OUT_714: usize = 1;
+fn aiur_fn_714(
+  inp: [G; IN_714],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_780], ExecError> {
+) -> Result<[G; OUT_714], 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 };
@@ -65074,17 +58618,17 @@ fn aiur_fn_780(
     match __v_1.as_canonical_u64() {
       1u64 => {
         let __v_11: G = G::from_u64(0);
-        let __ret: [G; OUT_780] = [__v_11];
-        record.function_queries[780].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_714] = [__v_11];
+        record.function_queries[714].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[780].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_780] = unsafe { *(result.output.as_ptr() as *const [G; OUT_780]) }; __ret } else { aiur_fn_780(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = unsafe { *(result.output.as_ptr() as *const [G; OUT_714]) }; __ret } else { aiur_fn_714(__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_780] = [__v_13];
-        record.function_queries[780].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_714] = [__v_13];
+        record.function_queries[714].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -65094,83 +58638,15 @@ fn aiur_fn_780(
   })
 }
 
-const INPUT_SIZE_781: usize = 7;
-const IN_781: usize = 7;
-const OUT_781: usize = 1;
-fn aiur_fn_781(
-  inp: [G; IN_781],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_781], 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];
-    match __v_1.as_canonical_u64() {
-      0u64 => {
-        let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; 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: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].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 __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; 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: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
-        let __v_13: G = __loaded[0];
-        let __v_14: G = __loaded[1];
-        let __v_15: G = __loaded[2];
-        let __v_16: G = __loaded[3];
-        let __v_17: G = __loaded[4];
-        let __v_18: G = __loaded[5];
-        let __v_19: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_3.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_19.as_canonical_u64() {
-          1u64 => {
-            let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_0, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[781].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_781] = unsafe { *(result.output.as_ptr() as *const [G; OUT_781]) }; __ret } else { aiur_fn_781(__args, record, io_buffer, __cu)? } };
-            let __v_20: G = __r_arr[0];
-            let __ret: [G; OUT_781] = [__v_20];
-            record.function_queries[781].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            let __v_20: G = (__v_0 - __v_3);
-            match __v_20.as_canonical_u64() {
-              0u64 => {
-                let __ret: [G; OUT_781] = [__v_4];
-                record.function_queries[781].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-              _ => {
-                let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_0, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[781].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_781] = unsafe { *(result.output.as_ptr() as *const [G; OUT_781]) }; __ret } else { aiur_fn_781(__args, record, io_buffer, __cu)? } };
-                let __v_21: G = __r_arr[0];
-                let __ret: [G; OUT_781] = [__v_21];
-                record.function_queries[781].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-                return Ok(__ret);
-              },
-            }
-          },
-        }
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_782: usize = 9;
-const IN_782: usize = 9;
-const OUT_782: usize = 45;
-fn aiur_fn_782(
-  inp: [G; IN_782],
+const INPUT_SIZE_715: usize = 9;
+const IN_715: usize = 9;
+const OUT_715: usize = 45;
+fn aiur_fn_715(
+  inp: [G; IN_715],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_782], ExecError> {
+) -> Result<[G; OUT_715], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -65231,16 +58707,16 @@ fn aiur_fn_782(
     let __v_55: G = __loaded[46];
     match __v_9.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__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[2].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__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[4].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } else { aiur_fn_4(__args, record, io_buffer, __cu)? } };
         let __v_56: G = __r_arr[0];
         match __v_56.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_782] = [__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];
-            record.function_queries[782].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_715] = [__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];
+            record.function_queries[715].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_12] = { let __args: [G; IN_12] = [__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[12].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_12] = unsafe { *(result.output.as_ptr() as *const [G; OUT_12]) }; __ret } else { aiur_fn_12(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__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[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } };
             let __v_57: G = __r_arr[0];
             let __v_58: G = __r_arr[1];
             let __v_59: G = __r_arr[2];
@@ -65249,7 +58725,7 @@ fn aiur_fn_782(
             let __v_62: G = __r_arr[5];
             let __v_63: G = __r_arr[6];
             let __v_64: G = __r_arr[7];
-            let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_55, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64]; let __cu = unconstrained; if let Some(result) = record.function_queries[782].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_782] = unsafe { *(result.output.as_ptr() as *const [G; OUT_782]) }; __ret } else { aiur_fn_782(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_55, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64]; let __cu = unconstrained; if let Some(result) = record.function_queries[715].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_715] = unsafe { *(result.output.as_ptr() as *const [G; OUT_715]) }; __ret } else { aiur_fn_715(__args, record, io_buffer, __cu)? } };
             let __v_65: G = __r_arr[0];
             let __v_66: G = __r_arr[1];
             let __v_67: G = __r_arr[2];
@@ -65295,8 +58771,8 @@ fn aiur_fn_782(
             let __v_107: G = __r_arr[42];
             let __v_108: G = __r_arr[43];
             let __v_109: G = __r_arr[44];
-            let __ret: [G; OUT_782] = [__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];
-            record.function_queries[782].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_715] = [__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];
+            record.function_queries[715].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -65311,56 +58787,15 @@ fn aiur_fn_782(
   })
 }
 
-const INPUT_SIZE_783: usize = 2;
-const IN_783: usize = 2;
-const OUT_783: usize = 1;
-fn aiur_fn_783(
-  inp: [G; IN_783],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_783], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; 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: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].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];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
-        let __ret: [G; OUT_783] = [__v_1];
-        record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __v_8: G = G::from_u64(0);
-        let __r_arr: [G; OUT_783] = { let __args: [G; IN_783] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[783].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_783] = unsafe { *(result.output.as_ptr() as *const [G; OUT_783]) }; __ret } else { aiur_fn_783(__args, record, io_buffer, __cu)? } };
-        let __v_9: G = __r_arr[0];
-        let __v_10: G = { let __values: [G; 6] = [__v_8, __v_3, __v_4, __v_5, __v_6, __v_9]; 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_783] = [__v_10];
-        record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_784: usize = 1;
-const IN_784: usize = 1;
-const OUT_784: usize = 8;
-fn aiur_fn_784(
-  inp: [G; IN_784],
+const INPUT_SIZE_716: usize = 1;
+const IN_716: usize = 1;
+const OUT_716: usize = 8;
+fn aiur_fn_716(
+  inp: [G; IN_716],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_784], ExecError> {
+) -> Result<[G; OUT_716], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; 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: 47 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr };
@@ -65421,12 +58856,12 @@ fn aiur_fn_784(
         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 __ret: [G; OUT_784] = [__v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55];
-        record.function_queries[784].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_716] = [__v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55];
+        record.function_queries[716].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_784] = { let __args: [G; IN_784] = [__v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[784].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_784] = unsafe { *(result.output.as_ptr() as *const [G; OUT_784]) }; __ret } else { aiur_fn_784(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__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];
@@ -65435,7 +58870,7 @@ fn aiur_fn_784(
         let __v_53: G = __r_arr[5];
         let __v_54: G = __r_arr[6];
         let __v_55: G = __r_arr[7];
-        let __r_arr: [G; OUT_11] = { let __args: [G; IN_11] = [__v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[11].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_11] = unsafe { *(result.output.as_ptr() as *const [G; OUT_11]) }; __ret } else { aiur_fn_11(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__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];
@@ -65444,8 +58879,8 @@ fn aiur_fn_784(
         let __v_61: G = __r_arr[5];
         let __v_62: G = __r_arr[6];
         let __v_63: G = __r_arr[7];
-        let __ret: [G; OUT_784] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63];
-        record.function_queries[784].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_716] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63];
+        record.function_queries[716].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -65455,55 +58890,15 @@ fn aiur_fn_784(
   })
 }
 
-const INPUT_SIZE_785: usize = 8;
-const IN_785: usize = 8;
-const OUT_785: usize = 6;
-fn aiur_fn_785(
-  inp: [G; IN_785],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_785], 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 __r_arr: [G; OUT_800] = { let __args: [G; IN_800] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[800].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_800] = unsafe { *(result.output.as_ptr() as *const [G; OUT_800]) }; __ret } else { aiur_fn_800(__args, record, io_buffer, __cu)? } };
-    let __v_8: G = __r_arr[0];
-    let __v_9: G = __r_arr[1];
-    let __v_10: G = __r_arr[2];
-    let __v_11: G = __r_arr[3];
-    let __v_12: G = __r_arr[4];
-    let __v_13: G = __r_arr[5];
-    match __v_8.as_canonical_u64() {
-      0u64 => {
-        let __v_14: G = G::from_u64(0);
-        let __v_15: G = G::from_u64(1);
-        let __ret: [G; OUT_785] = [__v_14, __v_15, __v_10, __v_11, __v_12, __v_13];
-        record.function_queries[785].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_786: usize = 1;
-const IN_786: usize = 1;
-const OUT_786: usize = 8;
-fn aiur_fn_786(
-  inp: [G; IN_786],
+const INPUT_SIZE_717: usize = 1;
+const IN_717: usize = 1;
+const OUT_717: usize = 8;
+fn aiur_fn_717(
+  inp: [G; IN_717],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_786], ExecError> {
+) -> Result<[G; OUT_717], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; 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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr };
@@ -65528,12 +58923,12 @@ fn aiur_fn_786(
         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 __ret: [G; OUT_786] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19];
-        record.function_queries[786].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_717] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19];
+        record.function_queries[717].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_786] = { let __args: [G; IN_786] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[786].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_786] = unsafe { *(result.output.as_ptr() as *const [G; OUT_786]) }; __ret } else { aiur_fn_786(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__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];
@@ -65542,7 +58937,7 @@ fn aiur_fn_786(
         let __v_17: G = __r_arr[5];
         let __v_18: G = __r_arr[6];
         let __v_19: G = __r_arr[7];
-        let __r_arr: [G; OUT_11] = { let __args: [G; IN_11] = [__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[11].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_11] = unsafe { *(result.output.as_ptr() as *const [G; OUT_11]) }; __ret } else { aiur_fn_11(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__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[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__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];
@@ -65551,8 +58946,8 @@ fn aiur_fn_786(
         let __v_25: G = __r_arr[5];
         let __v_26: G = __r_arr[6];
         let __v_27: G = __r_arr[7];
-        let __ret: [G; OUT_786] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27];
-        record.function_queries[786].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_717] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27];
+        record.function_queries[717].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -65562,54 +58957,15 @@ fn aiur_fn_786(
   })
 }
 
-const INPUT_SIZE_787: usize = 2;
-const IN_787: usize = 2;
-const OUT_787: usize = 1;
-fn aiur_fn_787(
-  inp: [G; IN_787],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_787], 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_787] = [__v_1];
-        record.function_queries[787].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __v_6: G = G::from_u64(0);
-        let __r_arr: [G; OUT_787] = { let __args: [G; IN_787] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[787].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_787] = unsafe { *(result.output.as_ptr() as *const [G; OUT_787]) }; __ret } else { aiur_fn_787(__args, record, io_buffer, __cu)? } };
-        let __v_7: G = __r_arr[0];
-        let __v_8: G = { let __values: [G; 4] = [__v_6, __v_3, __v_4, __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_787] = [__v_8];
-        record.function_queries[787].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_788: usize = 9;
-const IN_788: usize = 9;
-const OUT_788: usize = 34;
-fn aiur_fn_788(
-  inp: [G; IN_788],
+const INPUT_SIZE_718: usize = 9;
+const IN_718: usize = 9;
+const OUT_718: usize = 34;
+fn aiur_fn_718(
+  inp: [G; IN_718],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_788], ExecError> {
+) -> Result<[G; OUT_718], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -65659,16 +59015,16 @@ fn aiur_fn_788(
     let __v_44: G = __loaded[35];
     match __v_9.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__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[2].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__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[4].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } else { aiur_fn_4(__args, record, io_buffer, __cu)? } };
         let __v_45: G = __r_arr[0];
         match __v_45.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_788] = [__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];
-            record.function_queries[788].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_718] = [__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];
+            record.function_queries[718].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_12] = { let __args: [G; IN_12] = [__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[12].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_12] = unsafe { *(result.output.as_ptr() as *const [G; OUT_12]) }; __ret } else { aiur_fn_12(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__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[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__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];
@@ -65677,7 +59033,7 @@ fn aiur_fn_788(
             let __v_51: G = __r_arr[5];
             let __v_52: G = __r_arr[6];
             let __v_53: G = __r_arr[7];
-            let __r_arr: [G; OUT_788] = { let __args: [G; IN_788] = [__v_44, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[788].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_788] = unsafe { *(result.output.as_ptr() as *const [G; OUT_788]) }; __ret } else { aiur_fn_788(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_44, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__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];
@@ -65712,8 +59068,8 @@ fn aiur_fn_788(
             let __v_85: G = __r_arr[31];
             let __v_86: G = __r_arr[32];
             let __v_87: G = __r_arr[33];
-            let __ret: [G; OUT_788] = [__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];
-            record.function_queries[788].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_718] = [__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];
+            record.function_queries[718].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -65728,15 +59084,15 @@ fn aiur_fn_788(
   })
 }
 
-const INPUT_SIZE_789: usize = 1;
-const IN_789: usize = 1;
-const OUT_789: usize = 1;
-fn aiur_fn_789(
-  inp: [G; IN_789],
+const INPUT_SIZE_719: usize = 1;
+const IN_719: usize = 1;
+const OUT_719: usize = 1;
+fn aiur_fn_719(
+  inp: [G; IN_719],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_789], ExecError> {
+) -> Result<[G; OUT_719], 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 };
@@ -65746,14 +59102,14 @@ fn aiur_fn_789(
     match __v_1.as_canonical_u64() {
       1u64 => {
         let __v_4: G = G::from_u64(1);
-        let __ret: [G; OUT_789] = [__v_4];
-        record.function_queries[789].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_719] = [__v_4];
+        record.function_queries[719].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         let __v_4: G = G::from_u64(0);
-        let __ret: [G; OUT_789] = [__v_4];
-        record.function_queries[789].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_719] = [__v_4];
+        record.function_queries[719].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -65763,93 +59119,64 @@ fn aiur_fn_789(
   })
 }
 
-const INPUT_SIZE_790: usize = 2;
-const IN_790: usize = 2;
-const OUT_790: usize = 3;
-fn aiur_fn_790(
-  inp: [G; IN_790],
+const INPUT_SIZE_720: usize = 5;
+const IN_720: usize = 5;
+const OUT_720: usize = 1;
+fn aiur_fn_720(
+  inp: [G; IN_720],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_790], ExecError> {
+) -> Result<[G; OUT_720], 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_801] = { let __args: [G; IN_801] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[801].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_801] = unsafe { *(result.output.as_ptr() as *const [G; OUT_801]) }; __ret } else { aiur_fn_801(__args, record, io_buffer, __cu)? } };
-    let __v_2: G = __r_arr[0];
-    let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; 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: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr };
-    let __v_3: G = __loaded[0];
-    let __v_4: G = __loaded[1];
-    let __v_5: G = __loaded[2];
-    let __v_6: G = __loaded[3];
-    let __v_7: G = __loaded[4];
-    match __v_3.as_canonical_u64() {
-      0u64 => {
-        let __ret: [G; OUT_790] = [__v_4, __v_5, __v_6];
-        record.function_queries[790].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; 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: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].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];
+    match __v_5.as_canonical_u64() {
+      1u64 => {
+        let __v_11: G = G::from_u64(0);
+        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_12, __v_13, __v_13, __v_13, __v_13, __v_13]; 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 __v_15: G = { let __values: [G; 6] = [__v_11, __v_1, __v_2, __v_3, __v_4, __v_14]; 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_720] = [__v_15];
+        record.function_queries[720].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_791: usize = 2;
-const IN_791: usize = 2;
-const OUT_791: usize = 1;
-fn aiur_fn_791(
-  inp: [G; IN_791],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_791], 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_791] = [__v_0];
-        record.function_queries[791].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __v_11: G = G::from_u64(0);
+        let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_10, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } };
+        let __v_12: G = __r_arr[0];
+        let __v_13: G = { let __values: [G; 6] = [__v_11, __v_6, __v_7, __v_8, __v_9, __v_12]; 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_720] = [__v_13];
+        record.function_queries[720].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_791] = { let __args: [G; IN_791] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[791].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_791] = unsafe { *(result.output.as_ptr() as *const [G; OUT_791]) }; __ret } else { aiur_fn_791(__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];
-        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];
-        match __v_5.as_canonical_u64() {
-          0u64 => {
-            let __ret: [G; OUT_791] = [__v_10];
-            record.function_queries[791].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
-          },
-        }
+        return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_792: usize = 2;
-const IN_792: usize = 2;
-const OUT_792: usize = 1;
-fn aiur_fn_792(
-  inp: [G; IN_792],
+const INPUT_SIZE_721: usize = 2;
+const IN_721: usize = 2;
+const OUT_721: usize = 1;
+fn aiur_fn_721(
+  inp: [G; IN_721],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_792], ExecError> {
+) -> Result<[G; OUT_721], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -65858,8 +59185,8 @@ fn aiur_fn_792(
         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_792] = [__v_4];
-        record.function_queries[792].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_721] = [__v_4];
+        record.function_queries[721].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -65872,173 +59199,11 @@ fn aiur_fn_792(
             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_792] = { let __args: [G; IN_792] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[792].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_792] = unsafe { *(result.output.as_ptr() as *const [G; OUT_792]) }; __ret } else { aiur_fn_792(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } else { aiur_fn_721(__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_792] = [__v_9];
-            record.function_queries[792].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-          },
-        }
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_793: usize = 1;
-const IN_793: usize = 1;
-const OUT_793: usize = 1;
-fn aiur_fn_793(
-  inp: [G; IN_793],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_793], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __loaded: [G; 36] = { let __mq = record.memory_queries.get_mut(&36).ok_or(ExecError::InvalidMemorySize(36))?; 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: 36 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 36] = __args[..36].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 __v_35: G = __loaded[34];
-    let __v_36: G = __loaded[35];
-    match __v_1.as_canonical_u64() {
-      1u64 => {
-        let __v_37: G = G::from_u64(0);
-        let __ret: [G; OUT_793] = [__v_37];
-        record.function_queries[793].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __r_arr: [G; OUT_793] = { let __args: [G; IN_793] = [__v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[793].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_793] = unsafe { *(result.output.as_ptr() as *const [G; OUT_793]) }; __ret } else { aiur_fn_793(__args, record, io_buffer, __cu)? } };
-        let __v_37: G = __r_arr[0];
-        let __v_38: G = G::from_u64(1);
-        let __v_39: G = (__v_37 + __v_38);
-        let __ret: [G; OUT_793] = [__v_39];
-        record.function_queries[793].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_794: usize = 1;
-const IN_794: usize = 1;
-const OUT_794: usize = 1;
-fn aiur_fn_794(
-  inp: [G; IN_794],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_794], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; 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: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].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];
-    match __v_1.as_canonical_u64() {
-      1u64 => {
-        let __v_7: G = G::from_u64(0);
-        let __ret: [G; OUT_794] = [__v_7];
-        record.function_queries[794].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __r_arr: [G; OUT_794] = { let __args: [G; IN_794] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[794].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_794] = unsafe { *(result.output.as_ptr() as *const [G; OUT_794]) }; __ret } else { aiur_fn_794(__args, record, io_buffer, __cu)? } };
-        let __v_7: G = __r_arr[0];
-        let __v_8: G = G::from_u64(1);
-        let __v_9: G = (__v_7 + __v_8);
-        let __ret: [G; OUT_794] = [__v_9];
-        record.function_queries[794].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_795: usize = 2;
-const IN_795: usize = 2;
-const OUT_795: usize = 1;
-fn aiur_fn_795(
-  inp: [G; IN_795],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_795], 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_795] = [__v_4];
-        record.function_queries[795].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-        return Ok(__ret);
-      },
-      _ => {
-        let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; 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: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].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];
-        match __v_2.as_canonical_u64() {
-          0u64 => {
-            let __v_8: G = G::from_u64(0);
-            let __v_9: G = G::from_u64(1);
-            let __v_10: G = (__v_1 - __v_9);
-            let __r_arr: [G; OUT_795] = { let __args: [G; IN_795] = [__v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[795].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_795] = unsafe { *(result.output.as_ptr() as *const [G; OUT_795]) }; __ret } else { aiur_fn_795(__args, record, io_buffer, __cu)? } };
-            let __v_11: G = __r_arr[0];
-            let __v_12: G = { let __values: [G; 6] = [__v_8, __v_3, __v_4, __v_5, __v_6, __v_11]; 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_795] = [__v_12];
-            record.function_queries[795].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_721] = [__v_9];
+            record.function_queries[721].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -66050,28 +59215,28 @@ fn aiur_fn_795(
   })
 }
 
-const INPUT_SIZE_796: usize = 2;
-const IN_796: usize = 2;
-const OUT_796: usize = 1;
-fn aiur_fn_796(
-  inp: [G; IN_796],
+const INPUT_SIZE_722: usize = 2;
+const IN_722: usize = 2;
+const OUT_722: usize = 1;
+fn aiur_fn_722(
+  inp: [G; IN_722],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_796], ExecError> {
+) -> Result<[G; OUT_722], 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_796] = [__v_0];
-        record.function_queries[796].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_722] = [__v_0];
+        record.function_queries[722].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_796] = { let __args: [G; IN_796] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[796].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_796] = unsafe { *(result.output.as_ptr() as *const [G; OUT_796]) }; __ret } else { aiur_fn_796(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__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];
@@ -66079,8 +59244,8 @@ fn aiur_fn_796(
         let __v_7: G = __loaded[2];
         match __v_5.as_canonical_u64() {
           0u64 => {
-            let __ret: [G; OUT_796] = [__v_7];
-            record.function_queries[796].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_722] = [__v_7];
+            record.function_queries[722].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -66092,15 +59257,15 @@ fn aiur_fn_796(
   })
 }
 
-const INPUT_SIZE_797: usize = 1;
-const IN_797: usize = 1;
-const OUT_797: usize = 1;
-fn aiur_fn_797(
-  inp: [G; IN_797],
+const INPUT_SIZE_723: usize = 1;
+const IN_723: usize = 1;
+const OUT_723: usize = 1;
+fn aiur_fn_723(
+  inp: [G; IN_723],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_797], ExecError> {
+) -> Result<[G; OUT_723], 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 };
@@ -66112,17 +59277,17 @@ fn aiur_fn_797(
     match __v_1.as_canonical_u64() {
       1u64 => {
         let __v_6: G = G::from_u64(0);
-        let __ret: [G; OUT_797] = [__v_6];
-        record.function_queries[797].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_723] = [__v_6];
+        record.function_queries[723].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_797] = { let __args: [G; IN_797] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[797].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_797] = unsafe { *(result.output.as_ptr() as *const [G; OUT_797]) }; __ret } else { aiur_fn_797(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[723].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_723] = unsafe { *(result.output.as_ptr() as *const [G; OUT_723]) }; __ret } else { aiur_fn_723(__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_797] = [__v_8];
-        record.function_queries[797].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_723] = [__v_8];
+        record.function_queries[723].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -66132,15 +59297,55 @@ fn aiur_fn_797(
   })
 }
 
-const INPUT_SIZE_798: usize = 9;
-const IN_798: usize = 9;
-const OUT_798: usize = 1;
-fn aiur_fn_798(
-  inp: [G; IN_798],
+const INPUT_SIZE_724: usize = 8;
+const IN_724: usize = 8;
+const OUT_724: usize = 6;
+fn aiur_fn_724(
+  inp: [G; IN_724],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_798], ExecError> {
+) -> Result<[G; OUT_724], 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 __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } };
+    let __v_8: G = __r_arr[0];
+    let __v_9: G = __r_arr[1];
+    let __v_10: G = __r_arr[2];
+    let __v_11: G = __r_arr[3];
+    let __v_12: G = __r_arr[4];
+    let __v_13: G = __r_arr[5];
+    match __v_8.as_canonical_u64() {
+      0u64 => {
+        let __v_14: G = G::from_u64(0);
+        let __v_15: G = G::from_u64(1);
+        let __ret: [G; OUT_724] = [__v_14, __v_15, __v_10, __v_11, __v_12, __v_13];
+        record.function_queries[724].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_725: usize = 9;
+const IN_725: usize = 9;
+const OUT_725: usize = 1;
+fn aiur_fn_725(
+  inp: [G; IN_725],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_725], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -66169,17 +59374,17 @@ fn aiur_fn_798(
         let __v_21: G = G::from_u64(1);
         let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; 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_23: G = { let __values: [G; 10] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_22]; 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_798] = [__v_23];
-        record.function_queries[798].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_725] = [__v_23];
+        record.function_queries[725].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
         let __v_19: G = G::from_u64(0);
-        let __r_arr: [G; OUT_798] = { let __args: [G; IN_798] = [__v_18, __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[798].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_798] = unsafe { *(result.output.as_ptr() as *const [G; OUT_798]) }; __ret } else { aiur_fn_798(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_725] = { let __args: [G; IN_725] = [__v_18, __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[725].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_725] = unsafe { *(result.output.as_ptr() as *const [G; OUT_725]) }; __ret } else { aiur_fn_725(__args, record, io_buffer, __cu)? } };
         let __v_20: G = __r_arr[0];
         let __v_21: G = { let __values: [G; 10] = [__v_19, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_20]; 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_798] = [__v_21];
-        record.function_queries[798].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_725] = [__v_21];
+        record.function_queries[725].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -66189,15 +59394,56 @@ fn aiur_fn_798(
   })
 }
 
-const INPUT_SIZE_799: usize = 2;
-const IN_799: usize = 2;
-const OUT_799: usize = 1;
-fn aiur_fn_799(
-  inp: [G; IN_799],
+const INPUT_SIZE_726: usize = 1;
+const IN_726: usize = 1;
+const OUT_726: usize = 1;
+fn aiur_fn_726(
+  inp: [G; IN_726],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_799], ExecError> {
+) -> Result<[G; OUT_726], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; 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: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].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];
+    match __v_1.as_canonical_u64() {
+      1u64 => {
+        let __v_7: G = G::from_u64(0);
+        let __ret: [G; OUT_726] = [__v_7];
+        record.function_queries[726].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[726].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_726] = unsafe { *(result.output.as_ptr() as *const [G; OUT_726]) }; __ret } else { aiur_fn_726(__args, record, io_buffer, __cu)? } };
+        let __v_7: G = __r_arr[0];
+        let __v_8: G = G::from_u64(1);
+        let __v_9: G = (__v_7 + __v_8);
+        let __ret: [G; OUT_726] = [__v_9];
+        record.function_queries[726].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_727: usize = 2;
+const IN_727: usize = 2;
+const OUT_727: usize = 1;
+fn aiur_fn_727(
+  inp: [G; IN_727],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_727], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -66207,17 +59453,17 @@ fn aiur_fn_799(
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_799] = [__v_1];
-        record.function_queries[799].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_727] = [__v_1];
+        record.function_queries[727].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_799] = { let __args: [G; IN_799] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[799].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_799] = unsafe { *(result.output.as_ptr() as *const [G; OUT_799]) }; __ret } else { aiur_fn_799(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[727].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_727] = unsafe { *(result.output.as_ptr() as *const [G; OUT_727]) }; __ret } else { aiur_fn_727(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_799] = [__v_7];
-        record.function_queries[799].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_727] = [__v_7];
+        record.function_queries[727].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
@@ -66227,15 +59473,15 @@ fn aiur_fn_799(
   })
 }
 
-const INPUT_SIZE_800: usize = 8;
-const IN_800: usize = 8;
-const OUT_800: usize = 6;
-fn aiur_fn_800(
-  inp: [G; IN_800],
+const INPUT_SIZE_728: usize = 8;
+const IN_728: usize = 8;
+const OUT_728: usize = 6;
+fn aiur_fn_728(
+  inp: [G; IN_728],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_800], ExecError> {
+) -> Result<[G; OUT_728], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -66255,8 +59501,8 @@ fn aiur_fn_800(
         let __v_13: G = G::from_u64(1);
         let __v_14: G = G::from_u64(1);
         let __v_15: G = { let __values: [G; 6] = [__v_13, __v_14, __v_14, __v_14, __v_14, __v_14]; 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_800] = [__v_8, __v_9, __v_0, __v_1, __v_12, __v_15];
-        record.function_queries[800].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_728] = [__v_8, __v_9, __v_0, __v_1, __v_12, __v_15];
+        record.function_queries[728].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       0u64 => {
@@ -66277,22 +59523,22 @@ fn aiur_fn_800(
         let __v_20: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_4.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_20.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_800] = { let __args: [G; IN_800] = [__v_0, __v_1, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[800].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_800] = unsafe { *(result.output.as_ptr() as *const [G; OUT_800]) }; __ret } else { aiur_fn_800(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_0, __v_1, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__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 __r_arr: [G; OUT_802] = { let __args: [G; IN_802] = [__v_3, __v_4, __v_5, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[802].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_802] = unsafe { *(result.output.as_ptr() as *const [G; OUT_802]) }; __ret } else { aiur_fn_802(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_3, __v_4, __v_5, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[729].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_729] = unsafe { *(result.output.as_ptr() as *const [G; OUT_729]) }; __ret } else { aiur_fn_729(__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 __ret: [G; OUT_800] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32];
-            record.function_queries[800].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_728] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32];
+            record.function_queries[728].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
           _ => {
@@ -66302,27 +59548,27 @@ fn aiur_fn_800(
                 let __v_22: G = G::from_u64(0);
                 let __v_23: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; 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 __v_24: G = { let __values: [G; 6] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; 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_800] = [__v_22, __v_3, __v_0, __v_1, __v_23, __v_24];
-                record.function_queries[800].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_728] = [__v_22, __v_3, __v_0, __v_1, __v_23, __v_24];
+                record.function_queries[728].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_800] = { let __args: [G; IN_800] = [__v_0, __v_1, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[800].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_800] = unsafe { *(result.output.as_ptr() as *const [G; OUT_800]) }; __ret } else { aiur_fn_800(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_0, __v_1, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__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 __r_arr: [G; OUT_802] = { let __args: [G; IN_802] = [__v_3, __v_4, __v_5, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[802].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_802] = unsafe { *(result.output.as_ptr() as *const [G; OUT_802]) }; __ret } else { aiur_fn_802(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_3, __v_4, __v_5, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[729].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_729] = unsafe { *(result.output.as_ptr() as *const [G; OUT_729]) }; __ret } else { aiur_fn_729(__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 __ret: [G; OUT_800] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33];
-                record.function_queries[800].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_728] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33];
+                record.function_queries[728].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -66336,59 +59582,15 @@ fn aiur_fn_800(
   })
 }
 
-const INPUT_SIZE_801: usize = 2;
-const IN_801: usize = 2;
-const OUT_801: usize = 1;
-fn aiur_fn_801(
-  inp: [G; IN_801],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_801], 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_801] = [__v_0];
-        record.function_queries[801].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_801] = { let __args: [G; IN_801] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[801].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_801] = unsafe { *(result.output.as_ptr() as *const [G; OUT_801]) }; __ret } else { aiur_fn_801(__args, record, io_buffer, __cu)? } };
-        let __v_4: G = __r_arr[0];
-        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_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];
-        match __v_5.as_canonical_u64() {
-          0u64 => {
-            let __ret: [G; OUT_801] = [__v_9];
-            record.function_queries[801].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
-            return Ok(__ret);
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
-          },
-        }
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_802: usize = 15;
-const IN_802: usize = 15;
-const OUT_802: usize = 6;
-fn aiur_fn_802(
-  inp: [G; IN_802],
+const INPUT_SIZE_729: usize = 15;
+const IN_729: usize = 15;
+const OUT_729: usize = 6;
+fn aiur_fn_729(
+  inp: [G; IN_729],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_802], ExecError> {
+) -> Result<[G; OUT_729], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -66407,38 +59609,38 @@ fn aiur_fn_802(
     let __v_14: G = inp[14];
     match __v_0.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_803] = { let __args: [G; IN_803] = [__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]; let __cu = unconstrained; if let Some(result) = record.function_queries[803].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_803] = unsafe { *(result.output.as_ptr() as *const [G; OUT_803]) }; __ret } else { aiur_fn_803(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_730] = { let __args: [G; IN_730] = [__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]; let __cu = unconstrained; if let Some(result) = record.function_queries[730].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_730] = unsafe { *(result.output.as_ptr() as *const [G; OUT_730]) }; __ret } else { aiur_fn_730(__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 __ret: [G; OUT_802] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20];
-        record.function_queries[802].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_729] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20];
+        record.function_queries[729].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
       _ => {
         let __v_15: G = G::from_u64(0);
         let __v_16: G = { let __values: [G; 6] = [__v_3, __v_4, __v_5, __v_6, __v_7, __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 __v_17: G = { let __values: [G; 6] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; 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_802] = [__v_15, __v_0, __v_1, __v_2, __v_16, __v_17];
-        record.function_queries[802].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+        let __ret: [G; OUT_729] = [__v_15, __v_0, __v_1, __v_2, __v_16, __v_17];
+        record.function_queries[729].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_803: usize = 14;
-const IN_803: usize = 14;
-const OUT_803: usize = 6;
-fn aiur_fn_803(
-  inp: [G; IN_803],
+const INPUT_SIZE_730: usize = 14;
+const IN_730: usize = 14;
+const OUT_730: usize = 6;
+fn aiur_fn_730(
+  inp: [G; IN_730],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_803], ExecError> {
+) -> Result<[G; OUT_730], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -66478,8 +59680,8 @@ fn aiur_fn_803(
                     let __v_26: G = G::from_u64(1);
                     let __v_27: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; 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 __v_28: G = { let __values: [G; 6] = [__v_25, __v_26, __v_0, __v_1, __v_7, __v_27]; 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_803] = [__v_20, __v_21, __v_4, __v_5, __v_24, __v_28];
-                    record.function_queries[803].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_730] = [__v_20, __v_21, __v_4, __v_5, __v_24, __v_28];
+                    record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                   _ => {
@@ -66503,8 +59705,8 @@ fn aiur_fn_803(
                             let __v_32: G = G::from_u64(1);
                             let __v_33: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; 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 __v_34: G = { let __values: [G; 6] = [__v_31, __v_32, __v_0, __v_1, __v_25, __v_33]; 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_803] = [__v_26, __v_27, __v_22, __v_23, __v_30, __v_34];
-                            record.function_queries[803].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_730] = [__v_26, __v_27, __v_22, __v_23, __v_30, __v_34];
+                            record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                           _ => {
@@ -66532,8 +59734,8 @@ fn aiur_fn_803(
                                             let __v_38: G = G::from_u64(0);
                                             let __v_39: G = G::from_u64(1);
                                             let __v_40: G = { let __values: [G; 6] = [__v_38, __v_39, __v_10, __v_11, __v_31, __v_13]; 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_803] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40];
-                                            record.function_queries[803].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                            let __ret: [G; OUT_730] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40];
+                                            record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                             return Ok(__ret);
                                           },
                                           _ => {
@@ -66557,8 +59759,8 @@ fn aiur_fn_803(
                                                     let __v_44: G = G::from_u64(0);
                                                     let __v_45: G = G::from_u64(1);
                                                     let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; 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_803] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46];
-                                                    record.function_queries[803].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                    let __ret: [G; OUT_730] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46];
+                                                    record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                     return Ok(__ret);
                                                   },
                                                   _ => {
@@ -66566,8 +59768,8 @@ fn aiur_fn_803(
                                                     let __v_39: G = G::from_u64(1);
                                                     let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; 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 __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; 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_803] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                                    record.function_queries[803].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                    let __ret: [G; OUT_730] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
+                                                    record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                     return Ok(__ret);
                                                   },
                                                 }
@@ -66577,8 +59779,8 @@ fn aiur_fn_803(
                                                 let __v_39: G = G::from_u64(1);
                                                 let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; 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 __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; 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_803] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                                record.function_queries[803].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                let __ret: [G; OUT_730] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
+                                                record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                 return Ok(__ret);
                                               },
                                             }
@@ -66606,8 +59808,8 @@ fn aiur_fn_803(
                                                 let __v_44: G = G::from_u64(0);
                                                 let __v_45: G = G::from_u64(1);
                                                 let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; 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_803] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46];
-                                                record.function_queries[803].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                let __ret: [G; OUT_730] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46];
+                                                record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                 return Ok(__ret);
                                               },
                                               _ => {
@@ -66615,8 +59817,8 @@ fn aiur_fn_803(
                                                 let __v_39: G = G::from_u64(1);
                                                 let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; 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 __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; 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_803] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                                record.function_queries[803].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                let __ret: [G; OUT_730] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
+                                                record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                 return Ok(__ret);
                                               },
                                             }
@@ -66626,8 +59828,8 @@ fn aiur_fn_803(
                                             let __v_39: G = G::from_u64(1);
                                             let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; 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 __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; 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_803] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                            record.function_queries[803].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                            let __ret: [G; OUT_730] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
+                                            record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                             return Ok(__ret);
                                           },
                                         }
@@ -66639,8 +59841,8 @@ fn aiur_fn_803(
                                     let __v_27: G = G::from_u64(1);
                                     let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; 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 __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; 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_803] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                                    record.function_queries[803].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                    let __ret: [G; OUT_730] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
+                                    record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                     return Ok(__ret);
                                   },
                                 }
@@ -66650,8 +59852,8 @@ fn aiur_fn_803(
                                 let __v_27: G = G::from_u64(1);
                                 let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; 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 __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; 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_803] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                                record.function_queries[803].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_730] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
+                                record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -66683,8 +59885,8 @@ fn aiur_fn_803(
                                         let __v_38: G = G::from_u64(0);
                                         let __v_39: G = G::from_u64(1);
                                         let __v_40: G = { let __values: [G; 6] = [__v_38, __v_39, __v_10, __v_11, __v_31, __v_13]; 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_803] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40];
-                                        record.function_queries[803].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                        let __ret: [G; OUT_730] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40];
+                                        record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                         return Ok(__ret);
                                       },
                                       _ => {
@@ -66708,8 +59910,8 @@ fn aiur_fn_803(
                                                 let __v_44: G = G::from_u64(0);
                                                 let __v_45: G = G::from_u64(1);
                                                 let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; 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_803] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46];
-                                                record.function_queries[803].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                let __ret: [G; OUT_730] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46];
+                                                record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                 return Ok(__ret);
                                               },
                                               _ => {
@@ -66717,8 +59919,8 @@ fn aiur_fn_803(
                                                 let __v_39: G = G::from_u64(1);
                                                 let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; 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 __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; 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_803] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                                record.function_queries[803].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                let __ret: [G; OUT_730] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
+                                                record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                 return Ok(__ret);
                                               },
                                             }
@@ -66728,8 +59930,8 @@ fn aiur_fn_803(
                                             let __v_39: G = G::from_u64(1);
                                             let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; 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 __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; 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_803] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                            record.function_queries[803].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                            let __ret: [G; OUT_730] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
+                                            record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                             return Ok(__ret);
                                           },
                                         }
@@ -66757,8 +59959,8 @@ fn aiur_fn_803(
                                             let __v_44: G = G::from_u64(0);
                                             let __v_45: G = G::from_u64(1);
                                             let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; 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_803] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46];
-                                            record.function_queries[803].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                            let __ret: [G; OUT_730] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46];
+                                            record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                             return Ok(__ret);
                                           },
                                           _ => {
@@ -66766,8 +59968,8 @@ fn aiur_fn_803(
                                             let __v_39: G = G::from_u64(1);
                                             let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; 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 __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; 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_803] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                            record.function_queries[803].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                            let __ret: [G; OUT_730] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
+                                            record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                             return Ok(__ret);
                                           },
                                         }
@@ -66777,8 +59979,8 @@ fn aiur_fn_803(
                                         let __v_39: G = G::from_u64(1);
                                         let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; 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 __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; 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_803] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                        record.function_queries[803].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                        let __ret: [G; OUT_730] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
+                                        record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                         return Ok(__ret);
                                       },
                                     }
@@ -66790,8 +59992,8 @@ fn aiur_fn_803(
                                 let __v_27: G = G::from_u64(1);
                                 let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; 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 __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; 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_803] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                                record.function_queries[803].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_730] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
+                                record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -66801,8 +60003,8 @@ fn aiur_fn_803(
                             let __v_27: G = G::from_u64(1);
                             let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; 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 __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; 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_803] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                            record.function_queries[803].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_730] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
+                            record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                         }
@@ -66832,8 +60034,8 @@ fn aiur_fn_803(
                         let __v_32: G = G::from_u64(1);
                         let __v_33: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; 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 __v_34: G = { let __values: [G; 6] = [__v_31, __v_32, __v_0, __v_1, __v_25, __v_33]; 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_803] = [__v_26, __v_27, __v_22, __v_23, __v_30, __v_34];
-                        record.function_queries[803].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_730] = [__v_26, __v_27, __v_22, __v_23, __v_30, __v_34];
+                        record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       _ => {
@@ -66861,8 +60063,8 @@ fn aiur_fn_803(
                                         let __v_38: G = G::from_u64(0);
                                         let __v_39: G = G::from_u64(1);
                                         let __v_40: G = { let __values: [G; 6] = [__v_38, __v_39, __v_10, __v_11, __v_31, __v_13]; 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_803] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40];
-                                        record.function_queries[803].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                        let __ret: [G; OUT_730] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40];
+                                        record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                         return Ok(__ret);
                                       },
                                       _ => {
@@ -66886,8 +60088,8 @@ fn aiur_fn_803(
                                                 let __v_44: G = G::from_u64(0);
                                                 let __v_45: G = G::from_u64(1);
                                                 let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; 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_803] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46];
-                                                record.function_queries[803].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                let __ret: [G; OUT_730] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46];
+                                                record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                 return Ok(__ret);
                                               },
                                               _ => {
@@ -66895,8 +60097,8 @@ fn aiur_fn_803(
                                                 let __v_39: G = G::from_u64(1);
                                                 let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; 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 __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; 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_803] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                                record.function_queries[803].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                                let __ret: [G; OUT_730] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
+                                                record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                                 return Ok(__ret);
                                               },
                                             }
@@ -66906,8 +60108,8 @@ fn aiur_fn_803(
                                             let __v_39: G = G::from_u64(1);
                                             let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; 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 __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; 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_803] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                            record.function_queries[803].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                            let __ret: [G; OUT_730] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
+                                            record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                             return Ok(__ret);
                                           },
                                         }
@@ -66935,8 +60137,8 @@ fn aiur_fn_803(
                                             let __v_44: G = G::from_u64(0);
                                             let __v_45: G = G::from_u64(1);
                                             let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; 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_803] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46];
-                                            record.function_queries[803].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                            let __ret: [G; OUT_730] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46];
+                                            record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                             return Ok(__ret);
                                           },
                                           _ => {
@@ -66944,8 +60146,8 @@ fn aiur_fn_803(
                                             let __v_39: G = G::from_u64(1);
                                             let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; 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 __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; 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_803] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                            record.function_queries[803].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                            let __ret: [G; OUT_730] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
+                                            record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                             return Ok(__ret);
                                           },
                                         }
@@ -66955,8 +60157,8 @@ fn aiur_fn_803(
                                         let __v_39: G = G::from_u64(1);
                                         let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; 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 __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; 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_803] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                        record.function_queries[803].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                        let __ret: [G; OUT_730] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
+                                        record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                         return Ok(__ret);
                                       },
                                     }
@@ -66968,8 +60170,8 @@ fn aiur_fn_803(
                                 let __v_27: G = G::from_u64(1);
                                 let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; 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 __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; 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_803] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                                record.function_queries[803].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_730] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
+                                record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -66979,8 +60181,8 @@ fn aiur_fn_803(
                             let __v_27: G = G::from_u64(1);
                             let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; 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 __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; 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_803] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                            record.function_queries[803].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_730] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
+                            record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                         }
@@ -67012,8 +60214,8 @@ fn aiur_fn_803(
                                     let __v_38: G = G::from_u64(0);
                                     let __v_39: G = G::from_u64(1);
                                     let __v_40: G = { let __values: [G; 6] = [__v_38, __v_39, __v_10, __v_11, __v_31, __v_13]; 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_803] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40];
-                                    record.function_queries[803].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                    let __ret: [G; OUT_730] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40];
+                                    record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                     return Ok(__ret);
                                   },
                                   _ => {
@@ -67037,8 +60239,8 @@ fn aiur_fn_803(
                                             let __v_44: G = G::from_u64(0);
                                             let __v_45: G = G::from_u64(1);
                                             let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; 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_803] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46];
-                                            record.function_queries[803].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                            let __ret: [G; OUT_730] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46];
+                                            record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                             return Ok(__ret);
                                           },
                                           _ => {
@@ -67046,8 +60248,8 @@ fn aiur_fn_803(
                                             let __v_39: G = G::from_u64(1);
                                             let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; 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 __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; 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_803] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                            record.function_queries[803].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                            let __ret: [G; OUT_730] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
+                                            record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                             return Ok(__ret);
                                           },
                                         }
@@ -67057,8 +60259,8 @@ fn aiur_fn_803(
                                         let __v_39: G = G::from_u64(1);
                                         let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; 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 __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; 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_803] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                        record.function_queries[803].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                        let __ret: [G; OUT_730] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
+                                        record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                         return Ok(__ret);
                                       },
                                     }
@@ -67086,8 +60288,8 @@ fn aiur_fn_803(
                                         let __v_44: G = G::from_u64(0);
                                         let __v_45: G = G::from_u64(1);
                                         let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; 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_803] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46];
-                                        record.function_queries[803].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                        let __ret: [G; OUT_730] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46];
+                                        record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                         return Ok(__ret);
                                       },
                                       _ => {
@@ -67095,8 +60297,8 @@ fn aiur_fn_803(
                                         let __v_39: G = G::from_u64(1);
                                         let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; 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 __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; 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_803] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                        record.function_queries[803].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                        let __ret: [G; OUT_730] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
+                                        record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                         return Ok(__ret);
                                       },
                                     }
@@ -67106,8 +60308,8 @@ fn aiur_fn_803(
                                     let __v_39: G = G::from_u64(1);
                                     let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; 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 __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; 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_803] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                    record.function_queries[803].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                    let __ret: [G; OUT_730] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
+                                    record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                     return Ok(__ret);
                                   },
                                 }
@@ -67119,8 +60321,8 @@ fn aiur_fn_803(
                             let __v_27: G = G::from_u64(1);
                             let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; 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 __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; 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_803] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                            record.function_queries[803].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_730] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
+                            record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                         }
@@ -67130,8 +60332,8 @@ fn aiur_fn_803(
                         let __v_27: G = G::from_u64(1);
                         let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; 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 __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; 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_803] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                        record.function_queries[803].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_730] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
+                        record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                     }
@@ -67165,8 +60367,8 @@ fn aiur_fn_803(
                             let __v_26: G = G::from_u64(0);
                             let __v_27: G = G::from_u64(1);
                             let __v_28: G = { let __values: [G; 6] = [__v_26, __v_27, __v_10, __v_11, __v_19, __v_13]; 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_803] = [__v_20, __v_21, __v_16, __v_17, __v_25, __v_28];
-                            record.function_queries[803].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_730] = [__v_20, __v_21, __v_16, __v_17, __v_25, __v_28];
+                            record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                           _ => {
@@ -67190,8 +60392,8 @@ fn aiur_fn_803(
                                     let __v_32: G = G::from_u64(0);
                                     let __v_33: G = G::from_u64(1);
                                     let __v_34: G = { let __values: [G; 6] = [__v_32, __v_33, __v_22, __v_23, __v_24, __v_25]; 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_803] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34];
-                                    record.function_queries[803].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                    let __ret: [G; OUT_730] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34];
+                                    record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                     return Ok(__ret);
                                   },
                                   _ => {
@@ -67199,8 +60401,8 @@ fn aiur_fn_803(
                                     let __v_27: G = G::from_u64(1);
                                     let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; 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 __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; 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_803] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                                    record.function_queries[803].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                    let __ret: [G; OUT_730] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
+                                    record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                     return Ok(__ret);
                                   },
                                 }
@@ -67210,8 +60412,8 @@ fn aiur_fn_803(
                                 let __v_27: G = G::from_u64(1);
                                 let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; 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 __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; 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_803] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                                record.function_queries[803].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_730] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
+                                record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -67239,8 +60441,8 @@ fn aiur_fn_803(
                                 let __v_32: G = G::from_u64(0);
                                 let __v_33: G = G::from_u64(1);
                                 let __v_34: G = { let __values: [G; 6] = [__v_32, __v_33, __v_22, __v_23, __v_24, __v_25]; 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_803] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34];
-                                record.function_queries[803].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_730] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34];
+                                record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
@@ -67248,8 +60450,8 @@ fn aiur_fn_803(
                                 let __v_27: G = G::from_u64(1);
                                 let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; 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 __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; 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_803] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                                record.function_queries[803].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_730] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
+                                record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -67259,8 +60461,8 @@ fn aiur_fn_803(
                             let __v_27: G = G::from_u64(1);
                             let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; 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 __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; 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_803] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                            record.function_queries[803].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_730] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
+                            record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                         }
@@ -67272,8 +60474,8 @@ fn aiur_fn_803(
                     let __v_15: G = G::from_u64(1);
                     let __v_16: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; 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 __v_17: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; 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_803] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17];
-                    record.function_queries[803].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                    let __ret: [G; OUT_730] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17];
+                    record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                     return Ok(__ret);
                   },
                 }
@@ -67283,8 +60485,8 @@ fn aiur_fn_803(
                 let __v_15: G = G::from_u64(1);
                 let __v_16: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; 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 __v_17: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; 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_803] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17];
-                record.function_queries[803].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_730] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17];
+                record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -67316,8 +60518,8 @@ fn aiur_fn_803(
                         let __v_26: G = G::from_u64(0);
                         let __v_27: G = G::from_u64(1);
                         let __v_28: G = { let __values: [G; 6] = [__v_26, __v_27, __v_10, __v_11, __v_19, __v_13]; 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_803] = [__v_20, __v_21, __v_16, __v_17, __v_25, __v_28];
-                        record.function_queries[803].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_730] = [__v_20, __v_21, __v_16, __v_17, __v_25, __v_28];
+                        record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                       _ => {
@@ -67341,8 +60543,8 @@ fn aiur_fn_803(
                                 let __v_32: G = G::from_u64(0);
                                 let __v_33: G = G::from_u64(1);
                                 let __v_34: G = { let __values: [G; 6] = [__v_32, __v_33, __v_22, __v_23, __v_24, __v_25]; 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_803] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34];
-                                record.function_queries[803].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_730] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34];
+                                record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                               _ => {
@@ -67350,8 +60552,8 @@ fn aiur_fn_803(
                                 let __v_27: G = G::from_u64(1);
                                 let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; 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 __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; 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_803] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                                record.function_queries[803].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                                let __ret: [G; OUT_730] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
+                                record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                                 return Ok(__ret);
                               },
                             }
@@ -67361,8 +60563,8 @@ fn aiur_fn_803(
                             let __v_27: G = G::from_u64(1);
                             let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; 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 __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; 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_803] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                            record.function_queries[803].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_730] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
+                            record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                         }
@@ -67390,8 +60592,8 @@ fn aiur_fn_803(
                             let __v_32: G = G::from_u64(0);
                             let __v_33: G = G::from_u64(1);
                             let __v_34: G = { let __values: [G; 6] = [__v_32, __v_33, __v_22, __v_23, __v_24, __v_25]; 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_803] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34];
-                            record.function_queries[803].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_730] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34];
+                            record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                           _ => {
@@ -67399,8 +60601,8 @@ fn aiur_fn_803(
                             let __v_27: G = G::from_u64(1);
                             let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; 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 __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; 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_803] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                            record.function_queries[803].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                            let __ret: [G; OUT_730] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
+                            record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                             return Ok(__ret);
                           },
                         }
@@ -67410,8 +60612,8 @@ fn aiur_fn_803(
                         let __v_27: G = G::from_u64(1);
                         let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; 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 __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; 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_803] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                        record.function_queries[803].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                        let __ret: [G; OUT_730] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
+                        record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                         return Ok(__ret);
                       },
                     }
@@ -67423,8 +60625,8 @@ fn aiur_fn_803(
                 let __v_15: G = G::from_u64(1);
                 let __v_16: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; 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 __v_17: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; 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_803] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17];
-                record.function_queries[803].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+                let __ret: [G; OUT_730] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17];
+                record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
                 return Ok(__ret);
               },
             }
@@ -67434,8 +60636,8 @@ fn aiur_fn_803(
             let __v_15: G = G::from_u64(1);
             let __v_16: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; 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 __v_17: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; 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_803] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17];
-            record.function_queries[803].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
+            let __ret: [G; OUT_730] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17];
+            record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
             return Ok(__ret);
           },
         }
@@ -71106,371 +64308,6 @@ pub(crate) fn execute_generated(
       let __out = aiur_fn_730(__inp, record, io_buffer, false)?;
       return Ok(__out.to_vec());
     },
-    731u64 => {
-      let __inp: [G; IN_731] = args.try_into().expect("input size mismatch");
-      let __out = aiur_fn_731(__inp, record, io_buffer, false)?;
-      return Ok(__out.to_vec());
-    },
-    732u64 => {
-      let __inp: [G; IN_732] = args.try_into().expect("input size mismatch");
-      let __out = aiur_fn_732(__inp, record, io_buffer, false)?;
-      return Ok(__out.to_vec());
-    },
-    733u64 => {
-      let __inp: [G; IN_733] = args.try_into().expect("input size mismatch");
-      let __out = aiur_fn_733(__inp, record, io_buffer, false)?;
-      return Ok(__out.to_vec());
-    },
-    734u64 => {
-      let __inp: [G; IN_734] = args.try_into().expect("input size mismatch");
-      let __out = aiur_fn_734(__inp, record, io_buffer, false)?;
-      return Ok(__out.to_vec());
-    },
-    735u64 => {
-      let __inp: [G; IN_735] = args.try_into().expect("input size mismatch");
-      let __out = aiur_fn_735(__inp, record, io_buffer, false)?;
-      return Ok(__out.to_vec());
-    },
-    736u64 => {
-      let __inp: [G; IN_736] = args.try_into().expect("input size mismatch");
-      let __out = aiur_fn_736(__inp, record, io_buffer, false)?;
-      return Ok(__out.to_vec());
-    },
-    737u64 => {
-      let __inp: [G; IN_737] = args.try_into().expect("input size mismatch");
-      let __out = aiur_fn_737(__inp, record, io_buffer, false)?;
-      return Ok(__out.to_vec());
-    },
-    738u64 => {
-      let __inp: [G; IN_738] = args.try_into().expect("input size mismatch");
-      let __out = aiur_fn_738(__inp, record, io_buffer, false)?;
-      return Ok(__out.to_vec());
-    },
-    739u64 => {
-      let __inp: [G; IN_739] = args.try_into().expect("input size mismatch");
-      let __out = aiur_fn_739(__inp, record, io_buffer, false)?;
-      return Ok(__out.to_vec());
-    },
-    740u64 => {
-      let __inp: [G; IN_740] = args.try_into().expect("input size mismatch");
-      let __out = aiur_fn_740(__inp, record, io_buffer, false)?;
-      return Ok(__out.to_vec());
-    },
-    741u64 => {
-      let __inp: [G; IN_741] = args.try_into().expect("input size mismatch");
-      let __out = aiur_fn_741(__inp, record, io_buffer, false)?;
-      return Ok(__out.to_vec());
-    },
-    742u64 => {
-      let __inp: [G; IN_742] = args.try_into().expect("input size mismatch");
-      let __out = aiur_fn_742(__inp, record, io_buffer, false)?;
-      return Ok(__out.to_vec());
-    },
-    743u64 => {
-      let __inp: [G; IN_743] = args.try_into().expect("input size mismatch");
-      let __out = aiur_fn_743(__inp, record, io_buffer, false)?;
-      return Ok(__out.to_vec());
-    },
-    744u64 => {
-      let __inp: [G; IN_744] = args.try_into().expect("input size mismatch");
-      let __out = aiur_fn_744(__inp, record, io_buffer, false)?;
-      return Ok(__out.to_vec());
-    },
-    745u64 => {
-      let __inp: [G; IN_745] = args.try_into().expect("input size mismatch");
-      let __out = aiur_fn_745(__inp, record, io_buffer, false)?;
-      return Ok(__out.to_vec());
-    },
-    746u64 => {
-      let __inp: [G; IN_746] = args.try_into().expect("input size mismatch");
-      let __out = aiur_fn_746(__inp, record, io_buffer, false)?;
-      return Ok(__out.to_vec());
-    },
-    747u64 => {
-      let __inp: [G; IN_747] = args.try_into().expect("input size mismatch");
-      let __out = aiur_fn_747(__inp, record, io_buffer, false)?;
-      return Ok(__out.to_vec());
-    },
-    748u64 => {
-      let __inp: [G; IN_748] = args.try_into().expect("input size mismatch");
-      let __out = aiur_fn_748(__inp, record, io_buffer, false)?;
-      return Ok(__out.to_vec());
-    },
-    749u64 => {
-      let __inp: [G; IN_749] = args.try_into().expect("input size mismatch");
-      let __out = aiur_fn_749(__inp, record, io_buffer, false)?;
-      return Ok(__out.to_vec());
-    },
-    750u64 => {
-      let __inp: [G; IN_750] = args.try_into().expect("input size mismatch");
-      let __out = aiur_fn_750(__inp, record, io_buffer, false)?;
-      return Ok(__out.to_vec());
-    },
-    751u64 => {
-      let __inp: [G; IN_751] = args.try_into().expect("input size mismatch");
-      let __out = aiur_fn_751(__inp, record, io_buffer, false)?;
-      return Ok(__out.to_vec());
-    },
-    752u64 => {
-      let __inp: [G; IN_752] = args.try_into().expect("input size mismatch");
-      let __out = aiur_fn_752(__inp, record, io_buffer, false)?;
-      return Ok(__out.to_vec());
-    },
-    753u64 => {
-      let __inp: [G; IN_753] = args.try_into().expect("input size mismatch");
-      let __out = aiur_fn_753(__inp, record, io_buffer, false)?;
-      return Ok(__out.to_vec());
-    },
-    754u64 => {
-      let __inp: [G; IN_754] = args.try_into().expect("input size mismatch");
-      let __out = aiur_fn_754(__inp, record, io_buffer, false)?;
-      return Ok(__out.to_vec());
-    },
-    755u64 => {
-      let __inp: [G; IN_755] = args.try_into().expect("input size mismatch");
-      let __out = aiur_fn_755(__inp, record, io_buffer, false)?;
-      return Ok(__out.to_vec());
-    },
-    756u64 => {
-      let __inp: [G; IN_756] = args.try_into().expect("input size mismatch");
-      let __out = aiur_fn_756(__inp, record, io_buffer, false)?;
-      return Ok(__out.to_vec());
-    },
-    757u64 => {
-      let __inp: [G; IN_757] = args.try_into().expect("input size mismatch");
-      let __out = aiur_fn_757(__inp, record, io_buffer, false)?;
-      return Ok(__out.to_vec());
-    },
-    758u64 => {
-      let __inp: [G; IN_758] = args.try_into().expect("input size mismatch");
-      let __out = aiur_fn_758(__inp, record, io_buffer, false)?;
-      return Ok(__out.to_vec());
-    },
-    759u64 => {
-      let __inp: [G; IN_759] = args.try_into().expect("input size mismatch");
-      let __out = aiur_fn_759(__inp, record, io_buffer, false)?;
-      return Ok(__out.to_vec());
-    },
-    760u64 => {
-      let __inp: [G; IN_760] = args.try_into().expect("input size mismatch");
-      let __out = aiur_fn_760(__inp, record, io_buffer, false)?;
-      return Ok(__out.to_vec());
-    },
-    761u64 => {
-      let __inp: [G; IN_761] = args.try_into().expect("input size mismatch");
-      let __out = aiur_fn_761(__inp, record, io_buffer, false)?;
-      return Ok(__out.to_vec());
-    },
-    762u64 => {
-      let __inp: [G; IN_762] = args.try_into().expect("input size mismatch");
-      let __out = aiur_fn_762(__inp, record, io_buffer, false)?;
-      return Ok(__out.to_vec());
-    },
-    763u64 => {
-      let __inp: [G; IN_763] = args.try_into().expect("input size mismatch");
-      let __out = aiur_fn_763(__inp, record, io_buffer, false)?;
-      return Ok(__out.to_vec());
-    },
-    764u64 => {
-      let __inp: [G; IN_764] = args.try_into().expect("input size mismatch");
-      let __out = aiur_fn_764(__inp, record, io_buffer, false)?;
-      return Ok(__out.to_vec());
-    },
-    765u64 => {
-      let __inp: [G; IN_765] = args.try_into().expect("input size mismatch");
-      let __out = aiur_fn_765(__inp, record, io_buffer, false)?;
-      return Ok(__out.to_vec());
-    },
-    766u64 => {
-      let __inp: [G; IN_766] = args.try_into().expect("input size mismatch");
-      let __out = aiur_fn_766(__inp, record, io_buffer, false)?;
-      return Ok(__out.to_vec());
-    },
-    767u64 => {
-      let __inp: [G; IN_767] = args.try_into().expect("input size mismatch");
-      let __out = aiur_fn_767(__inp, record, io_buffer, false)?;
-      return Ok(__out.to_vec());
-    },
-    768u64 => {
-      let __inp: [G; IN_768] = args.try_into().expect("input size mismatch");
-      let __out = aiur_fn_768(__inp, record, io_buffer, false)?;
-      return Ok(__out.to_vec());
-    },
-    769u64 => {
-      let __inp: [G; IN_769] = args.try_into().expect("input size mismatch");
-      let __out = aiur_fn_769(__inp, record, io_buffer, false)?;
-      return Ok(__out.to_vec());
-    },
-    770u64 => {
-      let __inp: [G; IN_770] = args.try_into().expect("input size mismatch");
-      let __out = aiur_fn_770(__inp, record, io_buffer, false)?;
-      return Ok(__out.to_vec());
-    },
-    771u64 => {
-      let __inp: [G; IN_771] = args.try_into().expect("input size mismatch");
-      let __out = aiur_fn_771(__inp, record, io_buffer, false)?;
-      return Ok(__out.to_vec());
-    },
-    772u64 => {
-      let __inp: [G; IN_772] = args.try_into().expect("input size mismatch");
-      let __out = aiur_fn_772(__inp, record, io_buffer, false)?;
-      return Ok(__out.to_vec());
-    },
-    773u64 => {
-      let __inp: [G; IN_773] = args.try_into().expect("input size mismatch");
-      let __out = aiur_fn_773(__inp, record, io_buffer, false)?;
-      return Ok(__out.to_vec());
-    },
-    774u64 => {
-      let __inp: [G; IN_774] = args.try_into().expect("input size mismatch");
-      let __out = aiur_fn_774(__inp, record, io_buffer, false)?;
-      return Ok(__out.to_vec());
-    },
-    775u64 => {
-      let __inp: [G; IN_775] = args.try_into().expect("input size mismatch");
-      let __out = aiur_fn_775(__inp, record, io_buffer, false)?;
-      return Ok(__out.to_vec());
-    },
-    776u64 => {
-      let __inp: [G; IN_776] = args.try_into().expect("input size mismatch");
-      let __out = aiur_fn_776(__inp, record, io_buffer, false)?;
-      return Ok(__out.to_vec());
-    },
-    777u64 => {
-      let __inp: [G; IN_777] = args.try_into().expect("input size mismatch");
-      let __out = aiur_fn_777(__inp, record, io_buffer, false)?;
-      return Ok(__out.to_vec());
-    },
-    778u64 => {
-      let __inp: [G; IN_778] = args.try_into().expect("input size mismatch");
-      let __out = aiur_fn_778(__inp, record, io_buffer, false)?;
-      return Ok(__out.to_vec());
-    },
-    779u64 => {
-      let __inp: [G; IN_779] = args.try_into().expect("input size mismatch");
-      let __out = aiur_fn_779(__inp, record, io_buffer, false)?;
-      return Ok(__out.to_vec());
-    },
-    780u64 => {
-      let __inp: [G; IN_780] = args.try_into().expect("input size mismatch");
-      let __out = aiur_fn_780(__inp, record, io_buffer, false)?;
-      return Ok(__out.to_vec());
-    },
-    781u64 => {
-      let __inp: [G; IN_781] = args.try_into().expect("input size mismatch");
-      let __out = aiur_fn_781(__inp, record, io_buffer, false)?;
-      return Ok(__out.to_vec());
-    },
-    782u64 => {
-      let __inp: [G; IN_782] = args.try_into().expect("input size mismatch");
-      let __out = aiur_fn_782(__inp, record, io_buffer, false)?;
-      return Ok(__out.to_vec());
-    },
-    783u64 => {
-      let __inp: [G; IN_783] = args.try_into().expect("input size mismatch");
-      let __out = aiur_fn_783(__inp, record, io_buffer, false)?;
-      return Ok(__out.to_vec());
-    },
-    784u64 => {
-      let __inp: [G; IN_784] = args.try_into().expect("input size mismatch");
-      let __out = aiur_fn_784(__inp, record, io_buffer, false)?;
-      return Ok(__out.to_vec());
-    },
-    785u64 => {
-      let __inp: [G; IN_785] = args.try_into().expect("input size mismatch");
-      let __out = aiur_fn_785(__inp, record, io_buffer, false)?;
-      return Ok(__out.to_vec());
-    },
-    786u64 => {
-      let __inp: [G; IN_786] = args.try_into().expect("input size mismatch");
-      let __out = aiur_fn_786(__inp, record, io_buffer, false)?;
-      return Ok(__out.to_vec());
-    },
-    787u64 => {
-      let __inp: [G; IN_787] = args.try_into().expect("input size mismatch");
-      let __out = aiur_fn_787(__inp, record, io_buffer, false)?;
-      return Ok(__out.to_vec());
-    },
-    788u64 => {
-      let __inp: [G; IN_788] = args.try_into().expect("input size mismatch");
-      let __out = aiur_fn_788(__inp, record, io_buffer, false)?;
-      return Ok(__out.to_vec());
-    },
-    789u64 => {
-      let __inp: [G; IN_789] = args.try_into().expect("input size mismatch");
-      let __out = aiur_fn_789(__inp, record, io_buffer, false)?;
-      return Ok(__out.to_vec());
-    },
-    790u64 => {
-      let __inp: [G; IN_790] = args.try_into().expect("input size mismatch");
-      let __out = aiur_fn_790(__inp, record, io_buffer, false)?;
-      return Ok(__out.to_vec());
-    },
-    791u64 => {
-      let __inp: [G; IN_791] = args.try_into().expect("input size mismatch");
-      let __out = aiur_fn_791(__inp, record, io_buffer, false)?;
-      return Ok(__out.to_vec());
-    },
-    792u64 => {
-      let __inp: [G; IN_792] = args.try_into().expect("input size mismatch");
-      let __out = aiur_fn_792(__inp, record, io_buffer, false)?;
-      return Ok(__out.to_vec());
-    },
-    793u64 => {
-      let __inp: [G; IN_793] = args.try_into().expect("input size mismatch");
-      let __out = aiur_fn_793(__inp, record, io_buffer, false)?;
-      return Ok(__out.to_vec());
-    },
-    794u64 => {
-      let __inp: [G; IN_794] = args.try_into().expect("input size mismatch");
-      let __out = aiur_fn_794(__inp, record, io_buffer, false)?;
-      return Ok(__out.to_vec());
-    },
-    795u64 => {
-      let __inp: [G; IN_795] = args.try_into().expect("input size mismatch");
-      let __out = aiur_fn_795(__inp, record, io_buffer, false)?;
-      return Ok(__out.to_vec());
-    },
-    796u64 => {
-      let __inp: [G; IN_796] = args.try_into().expect("input size mismatch");
-      let __out = aiur_fn_796(__inp, record, io_buffer, false)?;
-      return Ok(__out.to_vec());
-    },
-    797u64 => {
-      let __inp: [G; IN_797] = args.try_into().expect("input size mismatch");
-      let __out = aiur_fn_797(__inp, record, io_buffer, false)?;
-      return Ok(__out.to_vec());
-    },
-    798u64 => {
-      let __inp: [G; IN_798] = args.try_into().expect("input size mismatch");
-      let __out = aiur_fn_798(__inp, record, io_buffer, false)?;
-      return Ok(__out.to_vec());
-    },
-    799u64 => {
-      let __inp: [G; IN_799] = args.try_into().expect("input size mismatch");
-      let __out = aiur_fn_799(__inp, record, io_buffer, false)?;
-      return Ok(__out.to_vec());
-    },
-    800u64 => {
-      let __inp: [G; IN_800] = args.try_into().expect("input size mismatch");
-      let __out = aiur_fn_800(__inp, record, io_buffer, false)?;
-      return Ok(__out.to_vec());
-    },
-    801u64 => {
-      let __inp: [G; IN_801] = args.try_into().expect("input size mismatch");
-      let __out = aiur_fn_801(__inp, record, io_buffer, false)?;
-      return Ok(__out.to_vec());
-    },
-    802u64 => {
-      let __inp: [G; IN_802] = args.try_into().expect("input size mismatch");
-      let __out = aiur_fn_802(__inp, record, io_buffer, false)?;
-      return Ok(__out.to_vec());
-    },
-    803u64 => {
-      let __inp: [G; IN_803] = args.try_into().expect("input size mismatch");
-      let __out = aiur_fn_803(__inp, record, io_buffer, false)?;
-      return Ok(__out.to_vec());
-    },
     _ => {
       return Err(ExecError::InvalidFunIdx(fun_idx));
     },
diff --git a/crates/ixvm-codegen/src/aiur_ixvm_witness.rs b/crates/ixvm-codegen/src/aiur_ixvm_witness.rs
index cda5885ca..f7b4e8c59 100644
--- a/crates/ixvm-codegen/src/aiur_ixvm_witness.rs
+++ b/crates/ixvm-codegen/src/aiur_ixvm_witness.rs
@@ -8,32 +8,37 @@
 //! Mirrors the per-channel layout documented in
 //! `Ix/IxVM/ClaimHarness.lean`:
 //!
-//! | Tier  | ch | purpose                  | key            | value     |
-//! |-------|----|--------------------------|----------------|-----------|
-//! | Ctrl  | 0  | claim wire bytes         | claim_digest   | bytes     |
-//! | Ctrl  | 1  | assumption tree bytes    | tree.root      | bytes     |
-//! | Const | 2  | constant wire bytes      | const addr     | bytes     |
-//! | Const | 3  | Defn reducibility hint   | Defn addr      | single G  |
-//! | Blob  | 4  | blob discriminator       | addr           | one byte  |
-//! | Blob  | 5  | blob raw bytes           | blob addr      | bytes     |
+//! | ch | purpose                  | key            | value     |
+//! |----|--------------------------|----------------|-----------|
+//! | 0  | claim wire bytes         | claim_digest   | bytes     |
+//! | 1  | assumption tree bytes    | tree.root      | bytes     |
+//! | 2  | constant wire bytes      | const addr     | bytes     |
+//! | 3  | Defn reducibility hint   | Defn addr      | single G  |
+//! | 4  | blob raw bytes           | blob addr      | bytes     |
 //!
-//! Soundness model unchanged — every byte-stream is blake3-verified
-//! kernel-side against its content-addressed key.
+//! An address is seeded on ch 2 iff it is a constant and on ch 4 iff it
+//! is a blob. The two sets are NOT disjoint: constant and blob addresses
+//! share a hash codomain, so one address can be read both ways, and the
+//! Expr context (`Ref`/`Prj` vs `Str`/`Nat`) is what says which table a
+//! reference means. Each channel is therefore seeded independently, and
+//! the kernel derives which it wants from that context, so no
+//! discriminator entry is shipped.
+//!
+//! Every byte-stream is blake3-verified kernel-side against its
+//! content-addressed key.
 //!
 //! # Parallelism
 //!
-//! Two hot phases use rayon for thread-level parallelism:
+//! The byte scope is computed by `witness_scope`, which delegates to
+//! `Env::bfs_closure` — a single sequential BFS that parses each closure
+//! member exactly once. The hot phase that follows uses rayon:
 //!
-//! * **Closure walk** (`closure_from_set`): each owned addr's
-//!   transitive walk runs on its own thread; results are unioned
-//!   into a `DashSet` to dedupe across threads.
 //! * **Byte→G conversion** (`add_entries`): for each addr in the
 //!   closure, the per-const `(key, data)` tuple is built in parallel
 //!   with rayon's `par_bridge`. Only the final IOBuffer assembly
 //!   (extending channel arenas + inserting into the key→(idx,len)
 //!   map) runs serially, since the arena `idx` is monotonic.
 
-use dashmap::DashSet;
 use multi_stark::p3_field::PrimeCharacteristicRing;
 use rayon::prelude::*;
 use rustc_hash::FxHashSet;
@@ -42,9 +47,9 @@ use aiur::G;
 use aiur::execute::{IOBuffer, IOKeyInfo};
 use ix_common::address::Address;
 use ix_common::env::ReducibilityHints;
+use ix_common::prim_addrs::PrimAddrs;
 use ixon::Env;
 use ixon::assumption_tree::AssumptionTree;
-use ixon::constant::ConstantInfo;
 use ixon::proof::Claim;
 
 /// Append `data` to the per-channel arena and record `(idx, len)`
@@ -82,66 +87,22 @@ fn hint_to_g(h: &ReducibilityHints) -> G {
   G::from_u64(v)
 }
 
-/// Single-source transitive closure over `Constant.refs` + projection
-/// blocks. Sequential BFS.
-fn closure_from(env: &Env, target: &Address, visited: &DashSet<Address>) {
-  let mut stack: Vec<Address> = vec![target.clone()];
-  while let Some(addr) = stack.pop() {
-    if !visited.insert(addr.clone()) {
-      continue;
-    }
-    let Some(c) = env.get_const(&addr) else {
-      continue;
-    };
-    for r in &c.refs {
-      if !visited.contains(r) {
-        stack.push(r.clone());
-      }
-    }
-    let block = match &c.info {
-      ConstantInfo::IPrj(p) => Some(&p.block),
-      ConstantInfo::CPrj(p) => Some(&p.block),
-      ConstantInfo::RPrj(p) => Some(&p.block),
-      ConstantInfo::DPrj(p) => Some(&p.block),
-      _ => None,
-    };
-    if let Some(b) = block
-      && !visited.contains(b)
-    {
-      stack.push(b.clone());
-    }
-  }
-}
-
-/// Parallel transitive closure: each owned addr's walk runs on its
-/// own thread, results unioned via the shared `DashSet`.
-fn closure_from_set(env: &Env, owned: &[Address]) -> FxHashSet<Address> {
-  let visited: DashSet<Address> = DashSet::new();
-  owned.par_iter().for_each(|a| closure_from(env, a, &visited));
-  visited.into_iter().collect()
-}
-
 /// Per-channel entry produced by the parallel scan over the closure.
 /// Sorted into the IOBuffer in a serial fold afterwards.
 struct ChannelEntries {
-  /// ch 2 const entries: `(key, bytes-as-G)`.
+  /// ch 2 const entries: `(key, bytes-as-G)`. An address may also appear
+  /// in `blobs` below — the two tables share a hash codomain, so one
+  /// address can be read both ways.
   consts: Vec<(Vec<G>, Vec<G>)>,
-  /// ch 5 blob entries: `(key, bytes-as-G)`.
+  /// ch 4 blob entries: `(key, bytes-as-G)`.
   blobs: Vec<(Vec<G>, Vec<G>)>,
-  /// ch 4 discriminator: `(key, [g])` — `g` is `1` for const, `0` for blob.
-  discs: Vec<(Vec<G>, G)>,
   /// ch 3 Defn hint: `(key, hint-G)`.
   hints: Vec<(Vec<G>, G)>,
 }
 
 impl ChannelEntries {
   fn new() -> Self {
-    Self {
-      consts: Vec::new(),
-      blobs: Vec::new(),
-      discs: Vec::new(),
-      hints: Vec::new(),
-    }
+    Self { consts: Vec::new(), blobs: Vec::new(), hints: Vec::new() }
   }
 }
 
@@ -155,34 +116,37 @@ fn add_entries_parallel(
 ) {
   let ch_const = G::from_u8(2);
   let ch_hint = G::from_u8(3);
-  let ch_disc = G::from_u8(4);
-  let ch_blob = G::from_u8(5);
-  let g_zero = G::ZERO;
-  let g_one = G::ONE;
+  let ch_blob = G::from_u8(4);
 
   // Pull the set of addrs we'll touch as a Vec for parallel iteration.
   let closure_vec: Vec<Address> = closure.iter().cloned().collect();
 
   // Phase A: parallel byte conversion per closure addr. Each thread
-  // produces its own partial `ChannelEntries`.
+  // produces its own partial `ChannelEntries`. A constant goes to ch 2
+  // and a blob to ch 4, and an address that is both is seeded on both.
+  // The kernel derives blob-vs-constant from Expr context, so no marker
+  // entry is needed.
   let partials: Vec<ChannelEntries> = closure_vec
     .par_chunks(256)
     .map(|chunk| {
       let mut p = ChannelEntries::new();
       for addr in chunk {
         let key = addr_key(addr);
-        // Const lookup first.
+        // The two lookups are INDEPENDENT: one address may be both a
+        // constant and a blob payload, since the two share a hash
+        // codomain and it is the Expr context (`Ref`/`Prj` vs
+        // `Str`/`Nat`) that says which table a reference means. The
+        // kernel faults ch 2 and ch 4 separately, so letting a constant
+        // hit suppress the blob seeding aborts such a check with
+        // `invalid IO key`. Mirrors the Lean seeder, which walks
+        // `consts` and `blobs` in separate passes.
         if let Some(lc) = env.consts.get(addr) {
           let data = bytes_to_g(lc.raw_bytes());
           p.consts.push((key.clone(), data));
-          p.discs.push((key, g_one));
-          continue;
         }
-        // Blob lookup.
         if let Some(blob) = env.blobs.get(addr) {
           let data = bytes_to_g(blob.value());
-          p.blobs.push((key.clone(), data));
-          p.discs.push((key, g_zero));
+          p.blobs.push((key, data));
         }
         // Neither — closure includes some addresses (e.g. blob refs
         // from const.refs) that may not be in env.blobs if the env
@@ -206,9 +170,6 @@ fn add_entries_parallel(
     for (key, data) in p.blobs {
       extend(io, ch_blob, key, data);
     }
-    for (key, disc) in p.discs {
-      extend(io, ch_disc, key, vec![disc]);
-    }
     for (key, hint) in p.hints {
       extend(io, ch_hint, key, vec![hint]);
     }
@@ -220,16 +181,15 @@ fn add_entries_parallel(
 /// ready to feed to `crate::ix::aiur_ixvm_runner::execute_ixvm`.
 ///
 /// Mirrors `IxVM.ClaimHarness.buildClaimWitness` on the
-/// `Claim.check addr none` branch: closure-from-addr seeds ch 2/3/4/5,
+/// `Claim.check addr none` branch: the witness scope seeds ch 2/3/4,
 /// claim bytes go to ch 0. Asm-tree variant deferred — caller falls
 /// back to Lean witness when `asm = Some _`.
 pub fn build_claim_check_witness(
   env: &Env,
   target: &Address,
 ) -> Result<(Claim, Vec<G>, IOBuffer), String> {
-  // Transitive closure rooted at `target`.
   let closure: FxHashSet<Address> =
-    closure_from_set(env, std::slice::from_ref(target));
+    witness_scope(env, std::slice::from_ref(target));
 
   let claim = Claim::Check { const_addr: target.clone(), assumptions: None };
   let mut claim_bytes: Vec<u8> = Vec::new();
@@ -243,38 +203,98 @@ pub fn build_claim_check_witness(
   };
   // ch 0: claim bytes
   extend(&mut io, G::ZERO, digest_key.clone(), bytes_to_g(&claim_bytes));
-  // ch 2/3/4/5: per-const/blob/hint entries — parallel byte conversion.
+  // ch 2/3/4: per-const/hint/blob entries — parallel byte conversion.
   add_entries_parallel(env, &closure, &mut io);
 
   Ok((claim, digest_key, io))
 }
 
-/// Build a `CheckEnv`-shaped shard witness directly in Rust. Returns
-/// `(claim, claim_digest_input, io_buffer)` ready to feed to
-/// `crate::ix::aiur_ixvm_runner::execute_ixvm`.
+/// Every primitive address the kernel can name, as the Lean seeder sees
+/// them: the parity table plus the reserved reduction markers. Built from
+/// `ix_common::prim_addrs::PrimAddrs`, which the `prim-addrs` parity test
+/// pins against `Ix.Tc.PrimAddrs`, so both seeders cover the same set by
+/// construction.
+fn prim_addrs() -> Vec<Address> {
+  let mut v: Vec<Address> = PrimAddrs::lean_parity_table()
+    .iter()
+    .map(|(name, hex)| {
+      Address::from_hex(hex)
+        .unwrap_or_else(|| panic!("primitive {name}: invalid address hex"))
+    })
+    .collect();
+  v.extend(PrimAddrs::reserved_marker_addrs().iter().map(|(_, a)| a.clone()));
+  v
+}
+
+/// The full WITNESS byte scope for `roots`: the env dependency closure
+/// plus every primitive present in the env.
+///
+/// `Env::bfs_closure` follows `refs`, each projection's `block` pointer,
+/// AND — for a `Muts` block — every member/constructor projection
+/// address it derives. That last edge is what the kernel needs: its
+/// lazy `get_ci` synthesizes IPrj/CPrj/RPrj/DPrj wrapper addrs via
+/// kernel-side blake3 and faults their bytes from ch 2, so wrappers
+/// over a closure block must ship even when no `Constant.refs` edge
+/// reaches them. The closure already carries them — expanding a wrapper
+/// only re-adds its (already present) block — so no reverse scan of the
+/// env is needed.
+///
+/// Primitives are seeded as additional ROOTS because the kernel
+/// FABRICATES references to them while reducing — `Const(nat_succ_addr(),
+/// ..)` and friends are built from addresses hardcoded in the Aiur
+/// source, not discovered by walking `refs` — and `get_ci` then faults
+/// their bytes from ch 2 like any other constant. Such a primitive need
+/// not appear anywhere in the target's ref closure, so a closure-only
+/// scope aborts with `invalid IO key`. Intersected with `env.consts`: a
+/// primitive the env does not carry is one the check cannot reach.
+///
+/// They are walked rather than merely inserted because def-eq
+/// delta-unfolds primitive BODIES, and a body's refs are reachable from
+/// nowhere else in the scope (the `strAppend*` arena fixtures exercise
+/// exactly this).
+///
+/// Every witness builder goes through here, so the byte scope cannot
+/// drift apart per call site. Mirrors
+/// `Ix.IxVM.ClaimHarness.closureFrom`.
+fn witness_scope(env: &Env, roots: &[Address]) -> FxHashSet<Address> {
+  let mut all_roots: Vec<Address> = roots.to_vec();
+  all_roots
+    .extend(prim_addrs().into_iter().filter(|a| env.consts.contains_key(a)));
+  env.bfs_closure(&all_roots)
+}
+
+/// Shard `CheckEnv` witness: thin-frontier claim (see
+/// `ixon::shard_claim`) plus the `bfs_closure` byte scope the kernel
+/// needs for its blake3-synthesized projection addresses. The frontier
+/// membership set stays at `closure_from` granularity — the claim's walk
+/// only follows refs + Prj→block edges; the block→wrapper edges
+/// `bfs_closure` adds are byte scope only.
 pub fn build_shard_check_env_witness(
   env: &Env,
   owned: &[Address],
 ) -> Result<(Claim, Vec<G>, IOBuffer), String> {
-  let owned_set: FxHashSet<Address> = owned.iter().cloned().collect();
-
-  // Transitive closure over `Constant.refs` + projection blocks, parallel
-  // per owned addr.
-  let closure = closure_from_set(env, owned);
-
-  let mut closure_vec: Vec<Address> = closure.iter().cloned().collect();
-  closure_vec.sort();
-  let frontier: Vec<Address> =
-    closure_vec.iter().filter(|a| !owned_set.contains(*a)).cloned().collect();
-  let env_tree = AssumptionTree::canonical(&closure_vec).ok_or_else(|| {
-    "build_shard_check_env_witness: empty closure".to_string()
-  })?;
+  // Claim + THIN frontier from the shared convention module — the
+  // single source of truth for shard CheckEnv digests (see
+  // ixon::shard_claim; Lean mirror:
+  // IxVM.ClaimHarness.shardCheckEnvClaimThin).
+  let (claim, frontier) = ixon::shard_claim::shard_check_env_claim(env, owned)
+    .ok_or_else(|| {
+      "build_shard_check_env_witness: empty owned set".to_string()
+    })?;
+  let mut owned_sorted: Vec<Address> = owned.to_vec();
+  owned_sorted.sort();
+  let owned_tree =
+    AssumptionTree::canonical(&owned_sorted).ok_or_else(|| {
+      "build_shard_check_env_witness: empty owned set".to_string()
+    })?;
   let asm_tree = AssumptionTree::canonical(&frontier);
-
-  let claim = Claim::CheckEnv {
-    root: env_tree.root(),
-    assumptions: asm_tree.as_ref().map(|t| t.root()),
-  };
+  debug_assert_eq!(
+    claim,
+    Claim::CheckEnv {
+      root: owned_tree.root(),
+      assumptions: asm_tree.as_ref().map(|t| t.root()),
+    }
+  );
   let mut claim_bytes: Vec<u8> = Vec::new();
   claim.put(&mut claim_bytes);
   let digest = Address::hash(&claim_bytes);
@@ -284,21 +304,66 @@ pub fn build_shard_check_env_witness(
     data: rustc_hash::FxHashMap::default(),
     map: rustc_hash::FxHashMap::default(),
   };
-  // ch 0: claim bytes
   extend(&mut io, G::ZERO, digest_key.clone(), bytes_to_g(&claim_bytes));
-  // ch 2/3/4/5 per-const/blob/hint entries — parallel byte conversion.
-  add_entries_parallel(env, &closure, &mut io);
-  // ch 1: env tree
+  let byte_scope = witness_scope(env, owned);
+  add_entries_parallel(env, &byte_scope, &mut io);
   extend(
     &mut io,
     G::ONE,
-    addr_key(&env_tree.root()),
-    bytes_to_g(&env_tree.ser()),
+    addr_key(&owned_tree.root()),
+    bytes_to_g(&owned_tree.ser()),
   );
-  // ch 1: asm tree (if present)
   if let Some(at) = asm_tree {
     extend(&mut io, G::ONE, addr_key(&at.root()), bytes_to_g(&at.ser()));
   }
 
   Ok((claim, digest_key, io))
 }
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+  use ixon::constant::{Axiom, Constant, ConstantInfo};
+  use ixon::expr::Expr;
+  use std::sync::Arc;
+
+  fn const_with_refs(refs: Vec<Address>) -> Constant {
+    Constant::with_tables(
+      ConstantInfo::Axio(Axiom {
+        is_unsafe: false,
+        lvls: 0,
+        typ: Arc::new(Expr::Sort(0)),
+      }),
+      Vec::new(),
+      refs,
+      Vec::new(),
+    )
+  }
+
+  /// One address can legitimately be read as both a constant and a blob
+  /// payload: blob and constant addresses share a hash codomain, and the
+  /// Expr context (`Ref`/`Prj` vs `Str`/`Nat`) is what disambiguates. The
+  /// kernel faults such an address from ch 2 and ch 4 independently, so
+  /// the witness must seed both — a constant hit must not suppress the
+  /// blob lookup, or the check aborts with `invalid IO key`.
+  #[test]
+  fn dual_use_address_is_seeded_on_both_channels() {
+    let env = Env::new();
+    let target = Address::hash(b"target");
+    let dual = Address::hash(b"dual");
+    env.store_const(target.clone(), const_with_refs(vec![dual.clone()]));
+    env.store_const(dual.clone(), const_with_refs(vec![]));
+    env.blobs.insert(dual.clone(), vec![1, 2, 3]);
+
+    let (_, _, io) = build_claim_check_witness(&env, &target).unwrap();
+    let key = addr_key(&dual);
+    assert!(
+      io.map.contains_key(&(G::from_u8(2), key.clone())),
+      "dual-use address missing from ch 2 (constant bytes)"
+    );
+    assert!(
+      io.map.contains_key(&(G::from_u8(4), key)),
+      "dual-use address missing from ch 4 (blob bytes)"
+    );
+  }
+}
diff --git a/crates/ixvm-codegen/src/aiur_multi_stark.rs b/crates/ixvm-codegen/src/aiur_multi_stark.rs
index 2e2276065..cc4c049b1 100644
--- a/crates/ixvm-codegen/src/aiur_multi_stark.rs
+++ b/crates/ixvm-codegen/src/aiur_multi_stark.rs
@@ -505,7 +505,7 @@ fn aiur_fn_9(
     let __v_7: G = inp[7];
     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() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("u64 -> field: value exceeds 2^56 (top byte must be zero)".to_string()) });
     }
     let __v_9: G = G::from_u64(256);
     let __v_10: G = (__v_9 * __v_1);
@@ -642,13 +642,13 @@ fn aiur_fn_12(
     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 !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_9: G = __r_arr[0];
     if (__v_9 != __v_0) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_0.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_0.as_canonical_u64(), msg: None });
     }
     let __r_arr: [G; OUT_11] = { let __args: [G; IN_11] = [__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[11].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_11] = unsafe { *(result.output.as_ptr() as *const [G; OUT_11]) }; __ret } else { aiur_fn_11(__args, record, io_buffer, __cu)? } };
     let __v_10: G = __r_arr[0];
     let __v_11: G = G::from_u64(1);
     if (__v_10 != __v_11) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_10.as_canonical_u64(), rhs: __v_11.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_10.as_canonical_u64(), rhs: __v_11.as_canonical_u64(), msg: None });
     }
     let __ret: [G; OUT_12] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8];
     record.function_queries[12].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
@@ -730,12 +730,12 @@ fn aiur_fn_16(
     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() });
+      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() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: None });
     }
     let __ret: [G; OUT_16] = [__v_1];
     record.function_queries[16].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
@@ -861,12 +861,12 @@ fn aiur_fn_21(
     let __v_11: G = (__v_6 * __v_10);
     let __v_12: G = G::from_u64(0);
     if (__v_11 != __v_12) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_12.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: None });
     }
     let __v_13: G = (__v_7 * __v_10);
     let __v_14: G = G::from_u64(0);
     if (__v_13 != __v_14) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_14.as_canonical_u64() });
+      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);
@@ -10978,7 +10978,7 @@ fn aiur_fn_124(
         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() });
+          return Err(ExecError::AssertEqMismatch { lhs: __v_17.as_canonical_u64(), rhs: __v_18.as_canonical_u64(), msg: None });
         }
         let __ret: [G; OUT_124] = [__v_15, __v_16];
         record.function_queries[124].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
@@ -11301,7 +11301,7 @@ fn aiur_fn_129(
                 let __v_13: G = __r_arr[0];
                 let __v_14: G = G::from_u64(1);
                 if (__v_13 != __v_14) {
-                  return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_14.as_canonical_u64() });
+                  return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: None });
                 }
                 let __v_15: G = G::from_u64(1);
                 let __ret: [G; OUT_129] = [__v_15];
@@ -11398,7 +11398,7 @@ fn aiur_fn_131(
     let __v_21: G = G::from_bool((__v_20 == G::ZERO));
     let __v_22: G = G::from_u64(1);
     if (__v_21 != __v_22) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_21.as_canonical_u64(), rhs: __v_22.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_21.as_canonical_u64(), rhs: __v_22.as_canonical_u64(), msg: None });
     }
     let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_0, __v_1, __v_6, __v_7, __v_16, __v_17, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[128].get_mut(&__args[..]) { 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_23: G = __r_arr[0];
@@ -11695,7 +11695,7 @@ fn aiur_fn_136(
             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() });
+              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_209] = { let __args: [G; IN_209] = [__v_8, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[209].get_mut(&__args[..]) { 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)? } };
@@ -11704,7 +11704,7 @@ fn aiur_fn_136(
             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() });
+              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);
@@ -12072,13 +12072,13 @@ fn aiur_fn_143(
         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() });
+          return Err(ExecError::AssertEqMismatch { lhs: __v_15.as_canonical_u64(), rhs: __v_16.as_canonical_u64(), msg: None });
         }
         let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[210].get_mut(&__args[..]) { 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_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() });
+          return Err(ExecError::AssertEqMismatch { lhs: __v_17.as_canonical_u64(), rhs: __v_18.as_canonical_u64(), msg: None });
         }
         let __ret: [G; OUT_143] = [__v_0, __v_1];
         record.function_queries[143].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
@@ -12128,7 +12128,7 @@ fn aiur_fn_143(
                         let __v_38: G = __r_arr[0];
                         let __v_39: G = G::from_u64(1);
                         if (__v_38 != __v_39) {
-                          return Err(ExecError::AssertEqMismatch { lhs: __v_38.as_canonical_u64(), rhs: __v_39.as_canonical_u64() });
+                          return Err(ExecError::AssertEqMismatch { lhs: __v_38.as_canonical_u64(), rhs: __v_39.as_canonical_u64(), msg: None });
                         }
                         let __v_40: G = G::from_u64(0);
                         let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[141].get_mut(&__args[..]) { 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)? } };
@@ -12146,7 +12146,7 @@ fn aiur_fn_143(
                         let __v_51: G = __r_arr[0];
                         let __v_52: G = G::from_u64(1);
                         if (__v_51 != __v_52) {
-                          return Err(ExecError::AssertEqMismatch { lhs: __v_51.as_canonical_u64(), rhs: __v_52.as_canonical_u64() });
+                          return Err(ExecError::AssertEqMismatch { lhs: __v_51.as_canonical_u64(), rhs: __v_52.as_canonical_u64(), msg: None });
                         }
                         let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_35, __v_36, __v_17, __v_20, __v_13, __v_23, __v_25, __v_37, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[143].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_143] = unsafe { *(result.output.as_ptr() as *const [G; OUT_143]) }; __ret } else { aiur_fn_143(__args, record, io_buffer, __cu)? } };
                         let __v_53: G = __r_arr[0];
@@ -12270,7 +12270,7 @@ fn aiur_fn_144(
                             let __v_54: G = G::from_bool((__v_53 == G::ZERO));
                             let __v_55: G = G::from_u64(1);
                             if (__v_54 != __v_55) {
-                              return Err(ExecError::AssertEqMismatch { lhs: __v_54.as_canonical_u64(), rhs: __v_55.as_canonical_u64() });
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_54.as_canonical_u64(), rhs: __v_55.as_canonical_u64(), msg: None });
                             }
                             let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { 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_56: G = __r_arr[0];
@@ -12282,7 +12282,7 @@ fn aiur_fn_144(
                             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() });
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_61.as_canonical_u64(), rhs: __v_62.as_canonical_u64(), msg: None });
                             }
                             let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { 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_63: G = __r_arr[0];
@@ -12290,7 +12290,7 @@ fn aiur_fn_144(
                             let __v_65: G = G::from_bool((__v_64 == G::ZERO));
                             let __v_66: G = G::from_u64(1);
                             if (__v_65 != __v_66) {
-                              return Err(ExecError::AssertEqMismatch { lhs: __v_65.as_canonical_u64(), rhs: __v_66.as_canonical_u64() });
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_65.as_canonical_u64(), rhs: __v_66.as_canonical_u64(), msg: None });
                             }
                             let __v_67: G = G::from_u64(0);
                             let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_15, __v_19, __v_18, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[137].get_mut(&__args[..]) { 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)? } };
@@ -12299,7 +12299,7 @@ fn aiur_fn_144(
                             let __v_69: G = __r_arr[0];
                             let __v_70: G = G::from_u64(1);
                             if (__v_69 != __v_70) {
-                              return Err(ExecError::AssertEqMismatch { lhs: __v_69.as_canonical_u64(), rhs: __v_70.as_canonical_u64() });
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_69.as_canonical_u64(), rhs: __v_70.as_canonical_u64(), msg: None });
                             }
                             let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { 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_71: G = __r_arr[0];
@@ -12307,7 +12307,7 @@ fn aiur_fn_144(
                             let __v_73: G = G::from_bool((__v_72 == G::ZERO));
                             let __v_74: G = G::from_u64(1);
                             if (__v_73 != __v_74) {
-                              return Err(ExecError::AssertEqMismatch { lhs: __v_73.as_canonical_u64(), rhs: __v_74.as_canonical_u64() });
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_73.as_canonical_u64(), rhs: __v_74.as_canonical_u64(), msg: None });
                             }
                             let __v_75: G = G::from_u64(0);
                             let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_15, __v_19, __v_18, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[137].get_mut(&__args[..]) { 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)? } };
@@ -12316,7 +12316,7 @@ fn aiur_fn_144(
                             let __v_77: G = __r_arr[0];
                             let __v_78: G = G::from_u64(1);
                             if (__v_77 != __v_78) {
-                              return Err(ExecError::AssertEqMismatch { lhs: __v_77.as_canonical_u64(), rhs: __v_78.as_canonical_u64() });
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_77.as_canonical_u64(), rhs: __v_78.as_canonical_u64(), msg: None });
                             }
                             let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { 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_79: G = __r_arr[0];
@@ -12324,7 +12324,7 @@ fn aiur_fn_144(
                             let __v_81: G = G::from_bool((__v_80 == G::ZERO));
                             let __v_82: G = G::from_u64(1);
                             if (__v_81 != __v_82) {
-                              return Err(ExecError::AssertEqMismatch { lhs: __v_81.as_canonical_u64(), rhs: __v_82.as_canonical_u64() });
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_81.as_canonical_u64(), rhs: __v_82.as_canonical_u64(), msg: None });
                             }
                             let __v_83: G = G::from_u64(0);
                             let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_15, __v_19, __v_18, __v_83]; let __cu = unconstrained; if let Some(result) = record.function_queries[137].get_mut(&__args[..]) { 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)? } };
@@ -12333,13 +12333,13 @@ fn aiur_fn_144(
                             let __v_85: G = __r_arr[0];
                             let __v_86: G = G::from_u64(1);
                             if (__v_85 != __v_86) {
-                              return Err(ExecError::AssertEqMismatch { lhs: __v_85.as_canonical_u64(), rhs: __v_86.as_canonical_u64() });
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_85.as_canonical_u64(), rhs: __v_86.as_canonical_u64(), msg: None });
                             }
                             let __v_87: G = (__v_44 - __v_20);
                             let __v_88: G = G::from_bool((__v_87 == G::ZERO));
                             let __v_89: G = G::from_u64(1);
                             if (__v_88 != __v_89) {
-                              return Err(ExecError::AssertEqMismatch { lhs: __v_88.as_canonical_u64(), rhs: __v_89.as_canonical_u64() });
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_88.as_canonical_u64(), rhs: __v_89.as_canonical_u64(), msg: None });
                             }
                             let __v_90: G = G::from_u64(0);
                             let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_23, __v_90]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { 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)? } };
@@ -12349,7 +12349,7 @@ fn aiur_fn_144(
                             let __v_93: G = __r_arr[0];
                             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() });
+                              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_144] = [__v_95];
@@ -12546,7 +12546,7 @@ fn aiur_fn_146(
         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() });
+          return Err(ExecError::AssertEqMismatch { lhs: __v_76.as_canonical_u64(), rhs: __v_77.as_canonical_u64(), msg: None });
         }
         let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { 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_78: G = __r_arr[0];
@@ -12554,13 +12554,13 @@ fn aiur_fn_146(
         let __v_80: G = G::from_bool((__v_79 == G::ZERO));
         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() });
+          return Err(ExecError::AssertEqMismatch { lhs: __v_80.as_canonical_u64(), rhs: __v_81.as_canonical_u64(), msg: None });
         }
         let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { 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_82: G = __r_arr[0];
         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() });
+          return Err(ExecError::AssertEqMismatch { lhs: __v_82.as_canonical_u64(), rhs: __v_83.as_canonical_u64(), msg: None });
         }
         let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_71, __v_72, __v_8, __v_61, __v_62, __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_73, __v_63, __v_6, __v_9, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[145].get_mut(&__args[..]) { 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_84: G = __r_arr[0];
@@ -14120,28 +14120,28 @@ fn aiur_fn_173(
         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() });
+          return Err(ExecError::AssertEqMismatch { lhs: __v_24.as_canonical_u64(), rhs: __v_25.as_canonical_u64(), msg: None });
         }
         let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { 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_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() });
+          return Err(ExecError::AssertEqMismatch { lhs: __v_26.as_canonical_u64(), rhs: __v_23.as_canonical_u64(), msg: None });
         }
         let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { 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];
         if (__v_27 != __v_23) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_27.as_canonical_u64(), rhs: __v_23.as_canonical_u64() });
+          return Err(ExecError::AssertEqMismatch { lhs: __v_27.as_canonical_u64(), rhs: __v_23.as_canonical_u64(), msg: None });
         }
         let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { 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_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() });
+          return Err(ExecError::AssertEqMismatch { lhs: __v_28.as_canonical_u64(), rhs: __v_23.as_canonical_u64(), msg: None });
         }
         let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { 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_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() });
+          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_173] = [__v_31];
@@ -15342,7 +15342,7 @@ fn aiur_fn_187(
             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() });
+              return Err(ExecError::AssertEqMismatch { lhs: __v_72.as_canonical_u64(), rhs: __v_73.as_canonical_u64(), msg: None });
             }
             let __r_arr: [G; OUT_20] = { let __args: [G; IN_20] = [__v_58, __v_59, __v_51, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[20].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_20] = unsafe { *(result.output.as_ptr() as *const [G; OUT_20]) }; __ret } else { aiur_fn_20(__args, record, io_buffer, __cu)? } };
             let __v_74: G = __r_arr[0];
@@ -15351,7 +15351,7 @@ fn aiur_fn_187(
             let __v_76: G = __r_arr[0];
             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() });
+              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 __v_79: G = (__v_9 + __v_78);
@@ -15562,7 +15562,7 @@ fn aiur_fn_190(
                     let __v_54: G = __r_arr[0];
                     let __v_55: G = G::from_u64(1);
                     if (__v_54 != __v_55) {
-                      return Err(ExecError::AssertEqMismatch { lhs: __v_54.as_canonical_u64(), rhs: __v_55.as_canonical_u64() });
+                      return Err(ExecError::AssertEqMismatch { lhs: __v_54.as_canonical_u64(), rhs: __v_55.as_canonical_u64(), msg: None });
                     }
                     let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { 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_56: G = __r_arr[0];
@@ -15572,7 +15572,7 @@ fn aiur_fn_190(
                     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() });
+                      return Err(ExecError::AssertEqMismatch { lhs: __v_59.as_canonical_u64(), rhs: __v_60.as_canonical_u64(), msg: None });
                     }
                     let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[210].get_mut(&__args[..]) { 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_61: G = __r_arr[0];
@@ -15582,7 +15582,7 @@ fn aiur_fn_190(
                     let __v_64: G = G::from_bool((__v_63 == G::ZERO));
                     let __v_65: G = G::from_u64(1);
                     if (__v_64 != __v_65) {
-                      return Err(ExecError::AssertEqMismatch { lhs: __v_64.as_canonical_u64(), rhs: __v_65.as_canonical_u64() });
+                      return Err(ExecError::AssertEqMismatch { lhs: __v_64.as_canonical_u64(), rhs: __v_65.as_canonical_u64(), msg: None });
                     }
                     let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[210].get_mut(&__args[..]) { 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_66: G = __r_arr[0];
@@ -15630,7 +15630,7 @@ fn aiur_fn_191(
         let __v_6: G = (__v_2 * __v_5);
         let __v_7: G = G::from_u64(0);
         if (__v_6 != __v_7) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_7.as_canonical_u64() });
+          return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_7.as_canonical_u64(), msg: None });
         }
         let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[191].get_mut(&__args[..]) { 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_8: G = __r_arr[0];
@@ -16045,7 +16045,7 @@ fn aiur_fn_198(
     let __v_116: G = __r_arr[1];
     let __v_117: G = (__v_66 + __v_67);
     if (__v_91 != __v_117) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_91.as_canonical_u64(), rhs: __v_117.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_91.as_canonical_u64(), rhs: __v_117.as_canonical_u64(), msg: None });
     }
     let __v_118: G = G::from_u64(1);
     let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_118, __v_94, __v_95]; let __cu = unconstrained; if let Some(result) = record.function_queries[98].get_mut(&__args[..]) { 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)? } };
@@ -16115,104 +16115,104 @@ fn aiur_fn_198(
     let __v_181: G = __r_arr[30];
     let __v_182: G = __r_arr[31];
     if (__v_151 != __v_0) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_151.as_canonical_u64(), rhs: __v_0.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_151.as_canonical_u64(), rhs: __v_0.as_canonical_u64(), msg: None });
     }
     if (__v_152 != __v_1) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_152.as_canonical_u64(), rhs: __v_1.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_152.as_canonical_u64(), rhs: __v_1.as_canonical_u64(), msg: None });
     }
     if (__v_153 != __v_2) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_153.as_canonical_u64(), rhs: __v_2.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_153.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: None });
     }
     if (__v_154 != __v_3) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_154.as_canonical_u64(), rhs: __v_3.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_154.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: None });
     }
     if (__v_155 != __v_4) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_155.as_canonical_u64(), rhs: __v_4.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_155.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: None });
     }
     if (__v_156 != __v_5) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_156.as_canonical_u64(), rhs: __v_5.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_156.as_canonical_u64(), rhs: __v_5.as_canonical_u64(), msg: None });
     }
     if (__v_157 != __v_6) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_157.as_canonical_u64(), rhs: __v_6.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_157.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: None });
     }
     if (__v_158 != __v_7) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_158.as_canonical_u64(), rhs: __v_7.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_158.as_canonical_u64(), rhs: __v_7.as_canonical_u64(), msg: None });
     }
     if (__v_159 != __v_8) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_159.as_canonical_u64(), rhs: __v_8.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_159.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: None });
     }
     if (__v_160 != __v_9) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_160.as_canonical_u64(), rhs: __v_9.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_160.as_canonical_u64(), rhs: __v_9.as_canonical_u64(), msg: None });
     }
     if (__v_161 != __v_10) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_161.as_canonical_u64(), rhs: __v_10.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_161.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: None });
     }
     if (__v_162 != __v_11) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_162.as_canonical_u64(), rhs: __v_11.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_162.as_canonical_u64(), rhs: __v_11.as_canonical_u64(), msg: None });
     }
     if (__v_163 != __v_12) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_163.as_canonical_u64(), rhs: __v_12.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_163.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: None });
     }
     if (__v_164 != __v_13) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_164.as_canonical_u64(), rhs: __v_13.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_164.as_canonical_u64(), rhs: __v_13.as_canonical_u64(), msg: None });
     }
     if (__v_165 != __v_14) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_165.as_canonical_u64(), rhs: __v_14.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_165.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: None });
     }
     if (__v_166 != __v_15) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_166.as_canonical_u64(), rhs: __v_15.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_166.as_canonical_u64(), rhs: __v_15.as_canonical_u64(), msg: None });
     }
     if (__v_167 != __v_16) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_167.as_canonical_u64(), rhs: __v_16.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_167.as_canonical_u64(), rhs: __v_16.as_canonical_u64(), msg: None });
     }
     if (__v_168 != __v_17) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_168.as_canonical_u64(), rhs: __v_17.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_168.as_canonical_u64(), rhs: __v_17.as_canonical_u64(), msg: None });
     }
     if (__v_169 != __v_18) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_169.as_canonical_u64(), rhs: __v_18.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_169.as_canonical_u64(), rhs: __v_18.as_canonical_u64(), msg: None });
     }
     if (__v_170 != __v_19) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_170.as_canonical_u64(), rhs: __v_19.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_170.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: None });
     }
     if (__v_171 != __v_20) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_171.as_canonical_u64(), rhs: __v_20.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_171.as_canonical_u64(), rhs: __v_20.as_canonical_u64(), msg: None });
     }
     if (__v_172 != __v_21) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_172.as_canonical_u64(), rhs: __v_21.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_172.as_canonical_u64(), rhs: __v_21.as_canonical_u64(), msg: None });
     }
     if (__v_173 != __v_22) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_173.as_canonical_u64(), rhs: __v_22.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_173.as_canonical_u64(), rhs: __v_22.as_canonical_u64(), msg: None });
     }
     if (__v_174 != __v_23) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_174.as_canonical_u64(), rhs: __v_23.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_174.as_canonical_u64(), rhs: __v_23.as_canonical_u64(), msg: None });
     }
     if (__v_175 != __v_24) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_175.as_canonical_u64(), rhs: __v_24.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_175.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: None });
     }
     if (__v_176 != __v_25) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_176.as_canonical_u64(), rhs: __v_25.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_176.as_canonical_u64(), rhs: __v_25.as_canonical_u64(), msg: None });
     }
     if (__v_177 != __v_26) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_177.as_canonical_u64(), rhs: __v_26.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_177.as_canonical_u64(), rhs: __v_26.as_canonical_u64(), msg: None });
     }
     if (__v_178 != __v_27) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_178.as_canonical_u64(), rhs: __v_27.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_178.as_canonical_u64(), rhs: __v_27.as_canonical_u64(), msg: None });
     }
     if (__v_179 != __v_28) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_179.as_canonical_u64(), rhs: __v_28.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_179.as_canonical_u64(), rhs: __v_28.as_canonical_u64(), msg: None });
     }
     if (__v_180 != __v_29) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_180.as_canonical_u64(), rhs: __v_29.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_180.as_canonical_u64(), rhs: __v_29.as_canonical_u64(), msg: None });
     }
     if (__v_181 != __v_30) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_181.as_canonical_u64(), rhs: __v_30.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_181.as_canonical_u64(), rhs: __v_30.as_canonical_u64(), msg: None });
     }
     if (__v_182 != __v_31) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_182.as_canonical_u64(), rhs: __v_31.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_182.as_canonical_u64(), rhs: __v_31.as_canonical_u64(), msg: None });
     }
     let __v_183: G = (__v_94 + __v_95);
     if (__v_108 != __v_183) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_108.as_canonical_u64(), rhs: __v_183.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_108.as_canonical_u64(), rhs: __v_183.as_canonical_u64(), msg: None });
     }
     let __r_arr: [G; OUT_62] = { let __args: [G; IN_62] = [__v_114]; let __cu = unconstrained; if let Some(result) = record.function_queries[62].get_mut(&__args[..]) { 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_184: G = __r_arr[0];
@@ -16281,100 +16281,100 @@ fn aiur_fn_198(
     let __v_246: G = __r_arr[30];
     let __v_247: G = __r_arr[31];
     if (__v_216 != __v_32) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_216.as_canonical_u64(), rhs: __v_32.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_216.as_canonical_u64(), rhs: __v_32.as_canonical_u64(), msg: None });
     }
     if (__v_217 != __v_33) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_217.as_canonical_u64(), rhs: __v_33.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_217.as_canonical_u64(), rhs: __v_33.as_canonical_u64(), msg: None });
     }
     if (__v_218 != __v_34) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_218.as_canonical_u64(), rhs: __v_34.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_218.as_canonical_u64(), rhs: __v_34.as_canonical_u64(), msg: None });
     }
     if (__v_219 != __v_35) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_219.as_canonical_u64(), rhs: __v_35.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_219.as_canonical_u64(), rhs: __v_35.as_canonical_u64(), msg: None });
     }
     if (__v_220 != __v_36) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_220.as_canonical_u64(), rhs: __v_36.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_220.as_canonical_u64(), rhs: __v_36.as_canonical_u64(), msg: None });
     }
     if (__v_221 != __v_37) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_221.as_canonical_u64(), rhs: __v_37.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_221.as_canonical_u64(), rhs: __v_37.as_canonical_u64(), msg: None });
     }
     if (__v_222 != __v_38) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_222.as_canonical_u64(), rhs: __v_38.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_222.as_canonical_u64(), rhs: __v_38.as_canonical_u64(), msg: None });
     }
     if (__v_223 != __v_39) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_223.as_canonical_u64(), rhs: __v_39.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_223.as_canonical_u64(), rhs: __v_39.as_canonical_u64(), msg: None });
     }
     if (__v_224 != __v_40) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_224.as_canonical_u64(), rhs: __v_40.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_224.as_canonical_u64(), rhs: __v_40.as_canonical_u64(), msg: None });
     }
     if (__v_225 != __v_41) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_225.as_canonical_u64(), rhs: __v_41.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_225.as_canonical_u64(), rhs: __v_41.as_canonical_u64(), msg: None });
     }
     if (__v_226 != __v_42) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_226.as_canonical_u64(), rhs: __v_42.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_226.as_canonical_u64(), rhs: __v_42.as_canonical_u64(), msg: None });
     }
     if (__v_227 != __v_43) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_227.as_canonical_u64(), rhs: __v_43.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_227.as_canonical_u64(), rhs: __v_43.as_canonical_u64(), msg: None });
     }
     if (__v_228 != __v_44) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_228.as_canonical_u64(), rhs: __v_44.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_228.as_canonical_u64(), rhs: __v_44.as_canonical_u64(), msg: None });
     }
     if (__v_229 != __v_45) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_229.as_canonical_u64(), rhs: __v_45.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_229.as_canonical_u64(), rhs: __v_45.as_canonical_u64(), msg: None });
     }
     if (__v_230 != __v_46) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_230.as_canonical_u64(), rhs: __v_46.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_230.as_canonical_u64(), rhs: __v_46.as_canonical_u64(), msg: None });
     }
     if (__v_231 != __v_47) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_231.as_canonical_u64(), rhs: __v_47.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_231.as_canonical_u64(), rhs: __v_47.as_canonical_u64(), msg: None });
     }
     if (__v_232 != __v_48) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_232.as_canonical_u64(), rhs: __v_48.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_232.as_canonical_u64(), rhs: __v_48.as_canonical_u64(), msg: None });
     }
     if (__v_233 != __v_49) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_233.as_canonical_u64(), rhs: __v_49.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_233.as_canonical_u64(), rhs: __v_49.as_canonical_u64(), msg: None });
     }
     if (__v_234 != __v_50) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_234.as_canonical_u64(), rhs: __v_50.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_234.as_canonical_u64(), rhs: __v_50.as_canonical_u64(), msg: None });
     }
     if (__v_235 != __v_51) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_235.as_canonical_u64(), rhs: __v_51.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_235.as_canonical_u64(), rhs: __v_51.as_canonical_u64(), msg: None });
     }
     if (__v_236 != __v_52) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_236.as_canonical_u64(), rhs: __v_52.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_236.as_canonical_u64(), rhs: __v_52.as_canonical_u64(), msg: None });
     }
     if (__v_237 != __v_53) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_237.as_canonical_u64(), rhs: __v_53.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_237.as_canonical_u64(), rhs: __v_53.as_canonical_u64(), msg: None });
     }
     if (__v_238 != __v_54) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_238.as_canonical_u64(), rhs: __v_54.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_238.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: None });
     }
     if (__v_239 != __v_55) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_239.as_canonical_u64(), rhs: __v_55.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_239.as_canonical_u64(), rhs: __v_55.as_canonical_u64(), msg: None });
     }
     if (__v_240 != __v_56) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_240.as_canonical_u64(), rhs: __v_56.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_240.as_canonical_u64(), rhs: __v_56.as_canonical_u64(), msg: None });
     }
     if (__v_241 != __v_57) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_241.as_canonical_u64(), rhs: __v_57.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_241.as_canonical_u64(), rhs: __v_57.as_canonical_u64(), msg: None });
     }
     if (__v_242 != __v_58) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_242.as_canonical_u64(), rhs: __v_58.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_242.as_canonical_u64(), rhs: __v_58.as_canonical_u64(), msg: None });
     }
     if (__v_243 != __v_59) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_243.as_canonical_u64(), rhs: __v_59.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_243.as_canonical_u64(), rhs: __v_59.as_canonical_u64(), msg: None });
     }
     if (__v_244 != __v_60) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_244.as_canonical_u64(), rhs: __v_60.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_244.as_canonical_u64(), rhs: __v_60.as_canonical_u64(), msg: None });
     }
     if (__v_245 != __v_61) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_245.as_canonical_u64(), rhs: __v_61.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_245.as_canonical_u64(), rhs: __v_61.as_canonical_u64(), msg: None });
     }
     if (__v_246 != __v_62) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_246.as_canonical_u64(), rhs: __v_62.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_246.as_canonical_u64(), rhs: __v_62.as_canonical_u64(), msg: None });
     }
     if (__v_247 != __v_63) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_247.as_canonical_u64(), rhs: __v_63.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_247.as_canonical_u64(), rhs: __v_63.as_canonical_u64(), msg: None });
     }
     let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_116.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).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_248: G = __loaded[0];
@@ -16383,25 +16383,25 @@ fn aiur_fn_198(
     let __v_251: G = G::from_u64(1);
     let __v_252: G = G::from_u64(1);
     if (__v_248 != __v_251) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_248.as_canonical_u64(), rhs: __v_251.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_248.as_canonical_u64(), rhs: __v_251.as_canonical_u64(), msg: None });
     }
     if (__v_249 != __v_252) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_249.as_canonical_u64(), rhs: __v_252.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_249.as_canonical_u64(), rhs: __v_252.as_canonical_u64(), msg: None });
     }
     if (__v_250 != __v_252) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_250.as_canonical_u64(), rhs: __v_252.as_canonical_u64() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_250.as_canonical_u64(), rhs: __v_252.as_canonical_u64(), msg: None });
     }
     let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__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[173].get_mut(&__args[..]) { 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_253: G = __r_arr[0];
     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() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_253.as_canonical_u64(), rhs: __v_254.as_canonical_u64(), msg: None });
     }
     let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__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_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_115]; let __cu = unconstrained; if let Some(result) = record.function_queries[190].get_mut(&__args[..]) { 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_255: G = __r_arr[0];
     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() });
+      return Err(ExecError::AssertEqMismatch { lhs: __v_255.as_canonical_u64(), rhs: __v_256.as_canonical_u64(), msg: None });
     }
     let __ret: [G; OUT_198] = [];
     record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));
diff --git a/crates/kernel/src/claim.rs b/crates/kernel/src/claim.rs
index 8d6dc65b6..46d0605c8 100644
--- a/crates/kernel/src/claim.rs
+++ b/crates/kernel/src/claim.rs
@@ -55,8 +55,27 @@ pub fn build_eval_claim(env: &Env, input: Address, output: Address) -> Claim {
   Claim::Eval { input, output, assumptions }
 }
 
-/// Build a whole-env check claim. Subject is the env's canonical merkle
-/// root; assumptions are the env's axiom leaves.
+/// Build a shard `CheckEnv` claim under the SHARD PROTOCOL convention:
+/// root over the owned set, assumptions over the THIN frontier (direct
+/// out-of-owned walk edges). Delegates to [`ixon::shard_claim`] — the
+/// single source of truth shared with the Aiur witness builders, so
+/// digests reproduce across the Rust and Aiur pipelines. The
+/// claim-exact check set (asm-cutoff walk + strict owned-membership)
+/// is [`ixon::shard_claim::walk_check_set`]; a native checker
+/// validating such a claim must check exactly that set — checking the
+/// whole env eagerly is a sound superset for DEV use but does not
+/// certify the claim (it misses the strict-membership coverage rule).
+pub fn build_shard_check_env_claim(
+  env: &Env,
+  owned: &[Address],
+) -> Option<(Claim, Vec<Address>)> {
+  ixon::shard_claim::shard_check_env_claim(env, owned)
+}
+
+/// Legacy whole-env check claim (DEV convention, not the shard
+/// protocol): subject is the env's canonical merkle root; assumptions
+/// are the env's axiom leaves. Digest-INCOMPATIBLE with the shard
+/// protocol's thin-frontier `CheckEnv` claims — do not mix pipelines.
 ///
 /// Returns `None` if the env has an empty const set (no subject root
 /// can be formed).
@@ -65,7 +84,7 @@ pub fn build_eval_claim(env: &Env, input: Address, output: Address) -> Claim {
 /// This forces a full env walk; callers that already hold structured
 /// constants are unaffected, but a freshly-loaded lazy env will pay
 /// the parse cost here.
-pub fn build_check_env_claim(env: &Env) -> Option<Claim> {
+pub fn build_check_env_claim_axioms(env: &Env) -> Option<Claim> {
   let root = env_merkle_root(env)?;
   let mut axioms: Vec<Address> = env
     .consts
@@ -110,14 +129,22 @@ mod tests {
     )
   }
 
+  /// A definition whose value NAMES every one of its `refs` entries via a
+  /// `Ref` node. The claim walk admits an index only when some Expr uses
+  /// it as a constant, so a fixture whose Exprs ignore `refs` produces no
+  /// edges and every frontier comes back empty.
   fn defn_const(refs: Vec<Address>) -> Constant {
+    let mut value = Expr::var(0);
+    for i in 0..refs.len() {
+      value = Expr::app(value, Expr::reference(i as u64, Vec::new()));
+    }
     Constant::with_tables(
       ConstantInfo::Defn(Definition {
         kind: DefKind::Definition,
         safety: DefinitionSafety::Safe,
         lvls: 0,
         typ: Expr::sort(0),
-        value: Expr::var(0),
+        value,
       }),
       Vec::new(),
       refs,
@@ -212,7 +239,7 @@ mod tests {
     let env = Env::new();
     let a = Address::hash(b"a");
     env.store_const(a.clone(), defn_const(vec![]));
-    match build_check_env_claim(&env).unwrap() {
+    match build_check_env_claim_axioms(&env).unwrap() {
       Claim::CheckEnv { root, assumptions: None } => {
         assert_eq!(Some(root), env_merkle_root(&env));
       },
@@ -227,7 +254,7 @@ mod tests {
     let ax = Address::hash(b"ax");
     env.store_const(a.clone(), defn_const(vec![ax.clone()]));
     env.store_const(ax.clone(), axiom_const(vec![]));
-    match build_check_env_claim(&env).unwrap() {
+    match build_check_env_claim_axioms(&env).unwrap() {
       Claim::CheckEnv { root, assumptions: Some(asm) } => {
         assert_eq!(Some(root), env_merkle_root(&env));
         assert_eq!(asm, leaf_hash(&ax));
@@ -239,7 +266,30 @@ mod tests {
   #[test]
   fn check_env_empty_returns_none() {
     let env = Env::new();
-    assert!(build_check_env_claim(&env).is_none());
+    assert!(build_check_env_claim_axioms(&env).is_none());
+  }
+
+  #[test]
+  fn shard_check_env_claim_is_thin_frontier() {
+    // a -> b -> c: owned {a} gives frontier {b} only — c is below the
+    // first layer and must NOT enter the asm set.
+    let env = Env::new();
+    let a = Address::hash(b"a");
+    let b = Address::hash(b"b");
+    let c = Address::hash(b"c");
+    env.store_const(a.clone(), defn_const(vec![b.clone()]));
+    env.store_const(b.clone(), defn_const(vec![c.clone()]));
+    env.store_const(c.clone(), defn_const(vec![]));
+    let (claim, frontier) =
+      build_shard_check_env_claim(&env, std::slice::from_ref(&a)).unwrap();
+    assert_eq!(frontier, vec![b.clone()]);
+    match claim {
+      Claim::CheckEnv { root, assumptions: Some(asm) } => {
+        assert_eq!(root, leaf_hash(&a));
+        assert_eq!(asm, leaf_hash(&b));
+      },
+      other => panic!("expected CheckEnv Some, got {other:?}"),
+    }
   }
 
   #[test]
diff --git a/crates/kernel/src/primitive.rs b/crates/kernel/src/primitive.rs
index 7ef71eb68..2307d808b 100644
--- a/crates/kernel/src/primitive.rs
+++ b/crates/kernel/src/primitive.rs
@@ -13,8 +13,6 @@
 //! Lean's `eagerReduce` compiles to the same canonical content address as
 //! `id`; address-only dispatch on the real constant would be unsound.
 
-use std::sync::LazyLock;
-
 use ix_common::address::Address;
 
 use super::env::KEnv;
@@ -154,844 +152,13 @@ pub struct Primitives<M: KernelMode> {
   pub string_dec_eq: KId<M>,
 }
 
-/// Hardcoded primitive addresses (for lookup in the env).
-pub struct PrimAddrs {
-  pub nat: Address,
-  pub nat_zero: Address,
-  pub nat_succ: Address,
-  pub nat_add: Address,
-  pub nat_pred: Address,
-  pub nat_sub: Address,
-  pub nat_mul: Address,
-  pub nat_pow: Address,
-  pub nat_gcd: Address,
-  pub nat_mod: Address,
-  pub nat_div: Address,
-  pub nat_bitwise: Address,
-  pub nat_beq: Address,
-  pub nat_ble: Address,
-  pub nat_land: Address,
-  pub nat_lor: Address,
-  pub nat_xor: Address,
-  pub nat_shift_left: Address,
-  pub nat_shift_right: Address,
-  pub bool_type: Address,
-  pub bool_true: Address,
-  pub bool_false: Address,
-  pub string: Address,
-  pub string_mk: Address,
-  pub char_type: Address,
-  pub char_mk: Address,
-  pub char_of_nat: Address,
-  pub string_of_list: Address,
-  pub string_to_byte_array: Address,
-  pub byte_array_empty: Address,
-  pub list: Address,
-  pub list_nil: Address,
-  pub list_cons: Address,
-  pub eq: Address,
-  pub eq_refl: Address,
-  pub quot_type: Address,
-  pub quot_ctor: Address,
-  pub quot_lift: Address,
-  pub quot_ind: Address,
-  pub reduce_bool: Address,
-  pub reduce_nat: Address,
-  pub eager_reduce: Address,
-  pub system_platform_num_bits: Address,
-  pub system_platform_get_num_bits: Address,
-  pub subtype_val: Address,
-  pub nat_dec_le: Address,
-  pub nat_dec_eq: Address,
-  pub nat_dec_lt: Address,
-  pub decidable_rec: Address,
-  pub decidable_is_true: Address,
-  pub decidable_is_false: Address,
-  pub nat_le_of_ble_eq_true: Address,
-  pub nat_not_le_of_not_ble_eq_true: Address,
-  pub nat_eq_of_beq_eq_true: Address,
-  pub nat_ne_of_beq_eq_false: Address,
-  pub fin: Address,
-  pub bool_no_confusion: Address,
-  // Int addresses — see `Primitives` for why these exist.
-  pub int: Address,
-  pub int_of_nat: Address,
-  pub int_neg_succ: Address,
-  pub int_add: Address,
-  pub int_sub: Address,
-  pub int_mul: Address,
-  pub int_neg: Address,
-  pub int_emod: Address,
-  pub int_ediv: Address,
-  pub int_bmod: Address,
-  pub int_bdiv: Address,
-  pub int_nat_abs: Address,
-  pub int_pow: Address,
-  pub int_dec_eq: Address,
-  pub int_dec_le: Address,
-  pub int_dec_lt: Address,
-  pub punit: Address,
-  pub pprod: Address,
-  pub pprod_mk: Address,
-
-  // See `Primitives<M>` for the rationale on these — names previously
-  // matched via name-based `is_const_named` and now resolved by address.
-  pub nat_rec: Address,
-  pub nat_cases_on: Address,
-  pub bit_vec: Address,
-  pub bit_vec_to_nat: Address,
-  pub bit_vec_of_nat: Address,
-  pub bit_vec_ult: Address,
-  pub decidable_decide: Address,
-  pub lt_lt: Address,
-  pub of_nat_of_nat: Address,
-  pub unit: Address,
-  pub punit_size_of_1: Address,
-  pub size_of_size_of: Address,
-  pub string_back: Address,
-  pub string_legacy_back: Address,
-  pub string_utf8_byte_size: Address,
-  pub string_append: Address,
-  pub string_dec_eq: Address,
-}
-
-impl Default for PrimAddrs {
-  fn default() -> Self {
-    Self::new()
-  }
-}
-
-impl PrimAddrs {
-  /// Addresses reserved for kernel-only reduction markers. These are not
-  /// Lean constants and must never be accepted as user environment entries.
-  pub fn reserved_marker_addrs() -> [(&'static str, Address); 2] {
-    let canon = Self::new();
-    let orig = Self::new_orig();
-    [
-      ("eager_reduce", canon.eager_reduce.clone()),
-      ("orig.eager_reduce", orig.eager_reduce.clone()),
-    ]
-  }
-
-  /// Canonical content-hash addresses, hardcoded from the Ixon-compiled
-  /// form of each primitive. Used by `Primitives::from_env` to resolve
-  /// primitives against a `kctx.kenv` whose KIds live at canonical
-  /// addresses. Regenerate with `lake test -- rust-kernel-build-primitives`.
-  pub fn new() -> Self {
-    let h = |hex: &str| -> Address {
-      Address::from_hex(hex).expect("invalid primitive address hex")
-    };
-    PrimAddrs {
-      nat: h(
-        "398a7706cf13f223992d173dce07946857240f49afcc743723e839f8f3f2b631",
-      ),
-      nat_zero: h(
-        "d397370157fb9ae2c6e1eda79feb10bf497401741aba788fab726cfa4c467db6",
-      ),
-      nat_succ: h(
-        "def52d1dad5f10cf9893c945e169718d62b15e2dd2c9066e597b9d4570ba056e",
-      ),
-      nat_add: h(
-        "d6f62a9779108f9fb6b66b31cc94c3d84ca72d8bea185e13137c50c7ef84c969",
-      ),
-      nat_pred: h(
-        "914f9c01884853652e9224dc511f867d5408517f3beb3192fc4477e0e9594c88",
-      ),
-      nat_sub: h(
-        "fdbd5fef40149c85333c6f3ccebb4be741270d2066336cb2eef87623744b72b0",
-      ),
-      nat_mul: h(
-        "6649665607b0750c2ca73f45de600f21cb670398504865bb97972438014f96d9",
-      ),
-      nat_pow: h(
-        "33c604451d01cb19a433668246b98f6e874bd630b78a791d7a373a979849a1cf",
-      ),
-      nat_gcd: h(
-        "3be48357ae17f74d4df27d697aed3f47c1307941f41affcf74da5f66d511a797",
-      ),
-      nat_mod: h(
-        "5179638b82cc8337914a7bcaad858c85888844e9a292430cac51e5eadc41a1af",
-      ),
-      nat_div: h(
-        "89deca86dd8f0066a5064fdb19a2c6897a3a9867caadc04f778d5c5cd0225362",
-      ),
-      nat_bitwise: h(
-        "d2075e323bed82f23eaf75ebc0fae4ceb80794240c046b90c51a94d07f5e885f",
-      ),
-      nat_beq: h(
-        "a34ab2daba34839e851fa3675124566f9f4dcde597349ecd54ae32f8424e44b8",
-      ),
-      nat_ble: h(
-        "de0befa84faa22d1394379a0ba67296e116660f781b4eb639dbbaba200ef2bf8",
-      ),
-      nat_land: h(
-        "818abb331150400d10b34fae4dfb9426741c4607baeed8d96271ba1659058ef8",
-      ),
-      nat_lor: h(
-        "9b76f32bbb1dbdf4ff68e0221225015df0ca2d2a6023c1a81306d4020d4ef397",
-      ),
-      nat_xor: h(
-        "97e325a96a6a1827194eeb7d2aa0d91921073aef9c2d333c24613e9ac956ed29",
-      ),
-      nat_shift_left: h(
-        "dc81e41cad1190377dbe604bfc3afe658a413b9a2dcfbcab79fad7b7a5cdd954",
-      ),
-      nat_shift_right: h(
-        "6db49304bf0f5acbfd1d9d9a0c1b7ae20ef99d0737887056129f5b5cb5a9ba8a",
-      ),
-      bool_type: h(
-        "e6eba3c8b4d19f6a1076b39fa89aec61dccbb960f83d9a62e6acf35a69c9a0a4",
-      ),
-      bool_true: h(
-        "a29a636176cf1135d077eb074798f9007c78e7801383e9cff363bae5edf05762",
-      ),
-      bool_false: h(
-        "dda12bcb330727f6dfb816bc9752aabd0520e6515b79fc8a5a9e713866f4c63e",
-      ),
-      string: h(
-        "7ab2d52ac52fd1f51809b718e53cd058ac4b50d65150e78ae619139ccf13c8fd",
-      ),
-      string_mk: h(
-        "9671fd4fcfbc061c93c2824864cf03124ffee7cc22308de12a7c826473e49906",
-      ),
-      char_type: h(
-        "29dd2d1986a525bdde49b4ad2defc349cec71d0484cd13f2da92f1fce89a4c79",
-      ),
-      char_mk: h(
-        "97afa5ad3d86895e6d155019b66c256cd1aa862b4e3c89d8c6580b61939ee541",
-      ),
-      char_of_nat: h(
-        "1a4c66f76760f5ef386de089682a55b752131e14a08557c4465ed17fe0c4dc86",
-      ),
-      // NOTE: `String.ofList` and `String.mk` share the canonical content-hash
-      // because both compile to the same Ixon form (a one-constructor `String`
-      // built from `List Char`). The Lean-side deprecation of `String.mk` in
-      // favor of `String.ofList` is orthogonal to the compiled representation.
-      string_of_list: h(
-        "9671fd4fcfbc061c93c2824864cf03124ffee7cc22308de12a7c826473e49906",
-      ),
-      string_to_byte_array: h(
-        "ed43c77e555593b6cd0d4bfbc4273ba122e1c0cdf1090571612a952f941eadb1",
-      ),
-      byte_array_empty: h(
-        "7cfba8fa95847c213aa4066110ba01a97fb597daf29f5c07f72366072f250744",
-      ),
-      list: h(
-        "144e207a88d1dfbde22a1b40689033b3a65a652c8f7500b9be3cb7f66366e0fe",
-      ),
-      list_nil: h(
-        "258a7364b87c99fe9f83e05e0d05c935609a0dc5df8d77939130efe5e0efca3e",
-      ),
-      list_cons: h(
-        "77d519259ec9fa489dbe0e3dc0b9352aef349ccdaa73ea58b08bb0bc683502a0",
-      ),
-      eq: h("036b63d5cc0961e920dee50e7364ec0dd3f9c38a9cace40e513b3835dec8e0c9"),
-      eq_refl: h(
-        "6c9bd60e1eae938e5626ca237dbca7fd950f2e99e234a99c23cfdc294ca7adce",
-      ),
-      quot_type: h(
-        "ab682c1778a17bbeae4032974df36447ce8bfcab6764a36d378566e3ad63cab8",
-      ),
-      quot_ctor: h(
-        "88266677fee774d109867e4b2240281aa2ee12d97920c1171cf5c1f6c87decf6",
-      ),
-      quot_lift: h(
-        "8dc4a97527812f8b7817b77cd079ace61450aa0185ac5885661ec2acba8b7bd0",
-      ),
-      quot_ind: h(
-        "124984bcb95208a0f30bb69d6736d3d59404e115e2202043fda3d34e01b0ad16",
-      ),
-      reduce_bool: h(
-        "1c170098e23143fd8fd6172cefd2ecee305072d2991113cfc4d52840a5a9fa78",
-      ),
-      reduce_nat: h(
-        "16853076b0d96d356d85485c56f3398014b6a0f2ee72ab16284a381d9c28e560",
-      ),
-      // Synthetic kernel-only marker. This is intentionally not the compiled
-      // Lean content hash: `eagerReduce` canonicalizes to the same content
-      // address as the real Lean constant `id`, so address-only dispatch would
-      // give ordinary `id` terms special reduction semantics.
-      eager_reduce: h(
-        "ff00000000000000000000000000000000000000000000000000000000000003",
-      ),
-      system_platform_num_bits: h(
-        "cf86263521d345c39076473ecdb9f6fd411b5b503bce83e2318ba3fb6f2376d8",
-      ),
-      system_platform_get_num_bits: h(
-        "f5d256c1dd794d02cfdf1762c9e41b13abe5bddde12d929d02ada37e4f40e85f",
-      ),
-      subtype_val: h(
-        "0b5958a3c822c99e8643a27f0b928dfb82c45447bee0353c200ad1b7d0e46092",
-      ),
-      nat_dec_le: h(
-        "ec1f60c1a28d48bc98fe3ef72d255132735a503cc36e3ff0f22e3d486e266ebe",
-      ),
-      nat_dec_eq: h(
-        "b4b26c2e29931c06e885914613faff5856138e5cb09620ddb6921a342ded8957",
-      ),
-      nat_dec_lt: h(
-        "c013c153ebf02028aed264333c1e4c85017d0b87025d7596a96971bb2b67921d",
-      ),
-      decidable_rec: h(
-        "ab3776985743af13a9cb1a7d2f8496997892e17983d14be5270a716570b35719",
-      ),
-      decidable_is_true: h(
-        "0f9ee8d9033d8f7b852f5b7152fd124f7d411930c992e0f457f8104b60a98381",
-      ),
-      decidable_is_false: h(
-        "0471e47158b2ae18d3c08dd5c77aae23e62d7bbc1e61116bc2813b1306bc5795",
-      ),
-      nat_le_of_ble_eq_true: h(
-        "21e0e0783b7617b0cc4eff4d1fab7cffefe01cd43da77e2f98d15094a0d8f086",
-      ),
-      nat_not_le_of_not_ble_eq_true: h(
-        "0183595b837b9b84da5f004b8ac4a4bbd3bc0628b99c8d550eb351f74ce16d48",
-      ),
-      nat_eq_of_beq_eq_true: h(
-        "9ce6e322f19481f21cf4c48f88789876b69b8a9b1520439c101d983f96ea60b7",
-      ),
-      nat_ne_of_beq_eq_false: h(
-        "3cf54d333821dd37683a0bf38739e687610a1991759220b77edec338ba3cfbc8",
-      ),
-      fin: h(
-        "745936fcb9d86c4457f0fd1e537e67077f46f7841108419dac7984008b565b97",
-      ),
-      bool_no_confusion: h(
-        "cd983a826c1e20c4570afca244916c79e20e816f618ffdda38be8a79079274ce",
-      ),
-      // Int primitives — canonical content-hashes from
-      // `lake test -- rust-kernel-build-primitives`.
-      int: h(
-        "a5ca2e1d5ceb8d43367bc34d69a50c1650a25dc10780aa0c378cdfa931ff0424",
-      ),
-      int_of_nat: h(
-        "09bc253147c36ce22c8e0ccd43c79b2cdae2206e0ddd168fca3609b2a584d3dc",
-      ),
-      int_neg_succ: h(
-        "267c0a9c92e75638fc73ed52a9f9c81647eeeceeff2144c1f97e65e2aff149f1",
-      ),
-      int_add: h(
-        "ca99084c9d2fcb4c5dd139aecaf159ebd04992d76230cb930f41b86074684817",
-      ),
-      int_sub: h(
-        "d3141231800e012e8db7c240f794e4929bfd156b3845e22f1cf31d3fe39aecd9",
-      ),
-      int_mul: h(
-        "482064e35634a95c0f252de73d687c24764ea4fa7dfd14cf7af8aa7531f17a5c",
-      ),
-      int_neg: h(
-        "f61c7d3fce595430f86f0cd52da5bcb00bf910edd85e14dc0402130fcce34ebd",
-      ),
-      int_emod: h(
-        "25c267ef44f15007f2d2e0819be6fb64902c33a7d27a6f2c9d61263898953804",
-      ),
-      int_ediv: h(
-        "49b34dcbff1e60532825ff5af477eb5de9810ee38e0f7a32014d54c8c1a3a3c5",
-      ),
-      int_bmod: h(
-        "6a6adf0e95b3a4ce18330ee22105712e9a640ee4311b5dd1022a8e0a30cba0af",
-      ),
-      int_bdiv: h(
-        "a4f1d7a3fe5b6b2ef9522fa537f1e622fbb8176f9fb3358c56cebe1a379b6184",
-      ),
-      int_nat_abs: h(
-        "83e3ce8a747520cc248a0dacf9bd1369467e4907e8aaaa433e1b438e1cad7ca4",
-      ),
-      int_pow: h(
-        "73ecccfeab8a63a3a0faf8d71dc77995bda83418b13cd399b1fa571b50b4575e",
-      ),
-      int_dec_eq: h(
-        "83fde38faa1164648e4227975abf2e8c260d7d4ef1c92676214ffe5826c2075d",
-      ),
-      int_dec_le: h(
-        "38d60ffa07b50678d0c3bf0c06f86cd7967b35e87ab071bc55899fcbaed4744f",
-      ),
-      int_dec_lt: h(
-        "5568e799198dad9fab0e784b7a4c58112bfc2688aecebe3c2c6563304210f956",
-      ),
-      punit: h(
-        "2dfc16af01b82b3b91c2ff704409d76236a83f956c0c6e6659a64fe21d76695b",
-      ),
-      pprod: h(
-        "81a422a42b2cb656b9a47e61a4422f89cdb0a0c166035d47bf5e2c2af02175fa",
-      ),
-      pprod_mk: h(
-        "c9c584da782cdc453306be9a643244fa0bcbfc3b5dbcbafe3f6b9d65df031fed",
-      ),
-      // Names previously matched via `is_const_named` in whnf.rs.
-      // Canonical content-hashes from `lake test -- rust-kernel-build-primitives`.
-      nat_rec: h(
-        "b975152f3f0cd9039433c68f5a5e5455f5cb5d917078baed0118b59067a74ea7",
-      ),
-      nat_cases_on: h(
-        "1917841d2085796dd7ba346de93a579571b5641c33fc400408ec55b5778a9a51",
-      ),
-      bit_vec: h(
-        "698dd593abfb63db362aaef57e70a793044fb657257291ee2c3e997caa423eae",
-      ),
-      bit_vec_to_nat: h(
-        "77a025c19f8be131fb9d5b0bec494817a26538b9a550abbbcec8099fae9de4e4",
-      ),
-      bit_vec_of_nat: h(
-        "90ca8130735c8d9a34005a8943b59fe1df182e08a9f2bfc7dc8323229659a574",
-      ),
-      bit_vec_ult: h(
-        "9fd8e7459a1d2deef00a4992a50419bac66c03082b58ade07422896f13033d74",
-      ),
-      decidable_decide: h(
-        "c5f7b19663e4499e70e1b2645162c5be15fa860f4f8157e331ae546c6f733723",
-      ),
-      lt_lt: h(
-        "cacaea97f4cdba0a4a0af71005d0517d1818ab2623bd2ea7fa8c637a0e3d3312",
-      ),
-      of_nat_of_nat: h(
-        "5a7292ad756ee1f2df4b92f18a27574a47cbbcf7094f98ab2865f92eb22342d7",
-      ),
-      unit: h(
-        "9232498667f765f437dedaac828e555f6cc67a20e6db28f614fdf3c262710feb",
-      ),
-      punit_size_of_1: h(
-        "7bd8e19f47f6eae620a5c39f243ce415dd6a77f09590f4c227cef363007f4012",
-      ),
-      size_of_size_of: h(
-        "389715f91e66683dc7108ccd853efce92949512fa659ad3c1902e754692919cd",
-      ),
-      string_back: h(
-        "e95c8d876e7ccf780418615e33b747a245d94facd7567fecbe7ae73a5ac09206",
-      ),
-      string_legacy_back: h(
-        "6bb6162aac7d6a01b6ec05580664e8a7f0d4b0ec1fc5afaae66018e9a1936dac",
-      ),
-      string_utf8_byte_size: h(
-        "def4433d9547b53175e24a3ac182c88b072af0d4ad33fd04ec4cf2ba3d95ea93",
-      ),
-      string_append: h(
-        "594fb1eedec7c939cc872b6c04cc3b3e0a9764fabec3e602ad9214d0e637d30f",
-      ),
-      string_dec_eq: h(
-        "82e5568d88e24f24d5befac30ce915010e92596f55a822e29f4876ea3a579394",
-      ),
-    }
-  }
-
-  /// `(lean_name, canonical_address_hex)` table from `Self::new()`,
-  /// in the same order as `Tests/Ix/Kernel/BuildPrimitives.lean`'s
-  /// `kernelPrimitives` array. Used by the regen-parity test
-  /// (`testPrimitivesParity`) to detect drift between hardcoded
-  /// addresses and freshly-compiled ones: if any future
-  /// compile/serialize change touches a primitive's content hash,
-  /// the parity test fails with a printable diff before the
-  /// breakage propagates to downstream consumers.
-  ///
-  /// Keep entries in lock-step with `kernelPrimitives` (same names,
-  /// same order). The `eager_reduce` entry is intentionally a
-  /// synthetic kernel marker — not the compiled Lean content hash —
-  /// because the real `eagerReduce` canonicalizes to the same
-  /// address as `id`; see the comment on the field in `new()`.
-  pub fn lean_parity_table() -> Vec<(&'static str, String)> {
-    let p = Self::new();
-    vec![
-      ("Nat", p.nat.hex()),
-      ("Nat.zero", p.nat_zero.hex()),
-      ("Nat.succ", p.nat_succ.hex()),
-      ("Nat.add", p.nat_add.hex()),
-      ("Nat.pred", p.nat_pred.hex()),
-      ("Nat.sub", p.nat_sub.hex()),
-      ("Nat.mul", p.nat_mul.hex()),
-      ("Nat.pow", p.nat_pow.hex()),
-      ("Nat.gcd", p.nat_gcd.hex()),
-      ("Nat.mod", p.nat_mod.hex()),
-      ("Nat.div", p.nat_div.hex()),
-      ("Nat.bitwise", p.nat_bitwise.hex()),
-      ("Nat.beq", p.nat_beq.hex()),
-      ("Nat.ble", p.nat_ble.hex()),
-      ("Nat.land", p.nat_land.hex()),
-      ("Nat.lor", p.nat_lor.hex()),
-      ("Nat.xor", p.nat_xor.hex()),
-      ("Nat.shiftLeft", p.nat_shift_left.hex()),
-      ("Nat.shiftRight", p.nat_shift_right.hex()),
-      ("Bool", p.bool_type.hex()),
-      ("Bool.true", p.bool_true.hex()),
-      ("Bool.false", p.bool_false.hex()),
-      ("String", p.string.hex()),
-      ("String.mk", p.string_mk.hex()),
-      ("Char", p.char_type.hex()),
-      ("Char.mk", p.char_mk.hex()),
-      ("Char.ofNat", p.char_of_nat.hex()),
-      ("String.ofList", p.string_of_list.hex()),
-      ("List", p.list.hex()),
-      ("List.nil", p.list_nil.hex()),
-      ("List.cons", p.list_cons.hex()),
-      ("Eq", p.eq.hex()),
-      ("Eq.refl", p.eq_refl.hex()),
-      ("Quot", p.quot_type.hex()),
-      ("Quot.mk", p.quot_ctor.hex()),
-      ("Quot.lift", p.quot_lift.hex()),
-      ("Quot.ind", p.quot_ind.hex()),
-      ("Lean.reduceBool", p.reduce_bool.hex()),
-      ("Lean.reduceNat", p.reduce_nat.hex()),
-      ("eagerReduce", p.eager_reduce.hex()),
-      ("System.Platform.numBits", p.system_platform_num_bits.hex()),
-      ("System.Platform.getNumBits", p.system_platform_get_num_bits.hex()),
-      ("Subtype.val", p.subtype_val.hex()),
-      ("String.toByteArray", p.string_to_byte_array.hex()),
-      ("ByteArray.empty", p.byte_array_empty.hex()),
-      ("Nat.decLe", p.nat_dec_le.hex()),
-      ("Nat.decEq", p.nat_dec_eq.hex()),
-      ("Nat.decLt", p.nat_dec_lt.hex()),
-      ("Decidable.rec", p.decidable_rec.hex()),
-      ("Decidable.isTrue", p.decidable_is_true.hex()),
-      ("Decidable.isFalse", p.decidable_is_false.hex()),
-      ("Nat.le_of_ble_eq_true", p.nat_le_of_ble_eq_true.hex()),
-      ("Nat.not_le_of_not_ble_eq_true", p.nat_not_le_of_not_ble_eq_true.hex()),
-      ("Nat.eq_of_beq_eq_true", p.nat_eq_of_beq_eq_true.hex()),
-      ("Nat.ne_of_beq_eq_false", p.nat_ne_of_beq_eq_false.hex()),
-      ("Fin", p.fin.hex()),
-      ("Bool.noConfusion", p.bool_no_confusion.hex()),
-      ("Int", p.int.hex()),
-      ("Int.ofNat", p.int_of_nat.hex()),
-      ("Int.negSucc", p.int_neg_succ.hex()),
-      ("Int.add", p.int_add.hex()),
-      ("Int.sub", p.int_sub.hex()),
-      ("Int.mul", p.int_mul.hex()),
-      ("Int.neg", p.int_neg.hex()),
-      ("Int.emod", p.int_emod.hex()),
-      ("Int.ediv", p.int_ediv.hex()),
-      ("Int.bmod", p.int_bmod.hex()),
-      ("Int.bdiv", p.int_bdiv.hex()),
-      ("Int.natAbs", p.int_nat_abs.hex()),
-      ("Int.pow", p.int_pow.hex()),
-      ("Int.decEq", p.int_dec_eq.hex()),
-      ("Int.decLe", p.int_dec_le.hex()),
-      ("Int.decLt", p.int_dec_lt.hex()),
-      ("PUnit", p.punit.hex()),
-      ("PProd", p.pprod.hex()),
-      ("PProd.mk", p.pprod_mk.hex()),
-      ("Nat.rec", p.nat_rec.hex()),
-      ("Nat.casesOn", p.nat_cases_on.hex()),
-      ("BitVec", p.bit_vec.hex()),
-      ("BitVec.toNat", p.bit_vec_to_nat.hex()),
-      ("BitVec.ofNat", p.bit_vec_of_nat.hex()),
-      ("BitVec.ult", p.bit_vec_ult.hex()),
-      ("Decidable.decide", p.decidable_decide.hex()),
-      ("LT.lt", p.lt_lt.hex()),
-      ("OfNat.ofNat", p.of_nat_of_nat.hex()),
-      ("Unit", p.unit.hex()),
-      ("PUnit._sizeOf_1", p.punit_size_of_1.hex()),
-      ("SizeOf.sizeOf", p.size_of_size_of.hex()),
-      ("String.back", p.string_back.hex()),
-      ("String.Legacy.back", p.string_legacy_back.hex()),
-      ("String.utf8ByteSize", p.string_utf8_byte_size.hex()),
-      ("String.append", p.string_append.hex()),
-      ("String.decEq", p.string_dec_eq.hex()),
-    ]
-  }
-
-  /// LEON content-hash addresses, hardcoded from
-  /// `ConstantInfo::get_hash()` applied to each primitive's original
-  /// (pre-compile) Lean declaration. Used by `Primitives::from_env_orig`
-  /// to resolve primitives against `orig_kenv` — the direct-ingress
-  /// environment produced by `lean_ingress` where KIds live at LEON
-  /// addresses rather than canonical addresses.
-  ///
-  /// Regenerate with `lake test -- rust-kernel-build-prim-origs`. The
-  /// failure mode when these drift is a synthetic `@<hex>` KId in every
-  /// primitive field of `orig_kenv.prims()`, which cascades into a
-  /// flood of `AppTypeMismatch` errors during original-constant
-  /// verification (any Nat literal reduction, Bool literal, `String`
-  /// coercion, or reducer-marker comparison will diverge from the real
-  /// `orig_kenv` entry for that primitive).
-  pub fn new_orig() -> Self {
-    let h = |hex: &str| -> Address {
-      Address::from_hex(hex).expect("invalid primitive address hex")
-    };
-    PrimAddrs {
-      nat: h(
-        "0c0524ffa66fdbc0c9d3f12faf1a27b2ecd331ffa06da24a78f832e4f4145589",
-      ),
-      nat_zero: h(
-        "adc9f7ba6a90c3caacf0be308c2012437e9dd810bfc2b9b286b4934be4e86cb1",
-      ),
-      nat_succ: h(
-        "e4f2b35614ae2c6487084cb96e90852643a043296bc682b469ccfd430650cf8d",
-      ),
-      nat_add: h(
-        "01ec6fdf63bc0de137becade5f420102f35338bef318b9d5fd44e70db82c3f42",
-      ),
-      nat_pred: h(
-        "26245a09319bcf9d55a08431bce3b9d8a8d09e3dad25b9a83cc666e3736deeb4",
-      ),
-      nat_sub: h(
-        "4017cc8c3a02d3eeab73d5cc5af8afe771f60d980f107fd24d3a1d59aaa41d5a",
-      ),
-      nat_mul: h(
-        "a095de37a0e713551bd237f414ac7317f68b3986ce5734ca0063c504457f24de",
-      ),
-      nat_pow: h(
-        "6e9d84492674fb8a36008214b2150c76a83da4af1cadcc303d5d680d0477235a",
-      ),
-      nat_gcd: h(
-        "09ae07bc024bfb0317aa228d1274294b40aebb4229dc7014f7b22d56fa46a760",
-      ),
-      nat_mod: h(
-        "7ee6854a6ef5afb0e83f8aae9ccc2cbb457110bd1013a6f7615a98667a34322a",
-      ),
-      nat_div: h(
-        "acb405101f168dc08bf410d54a8f588893776ab61be81f2c7e5e1dd05685560e",
-      ),
-      nat_bitwise: h(
-        "21a51ddc3faeec42c0f3897955d5e24c40ffb1924824bd919da5db0346962a98",
-      ),
-      nat_beq: h(
-        "8960bdbe7e09dd15582a50de197cb5c28d87b147e3479e417b4c2ad43011f90c",
-      ),
-      nat_ble: h(
-        "7e679407c5e5af964d3d3cb98c9b606218c6f4ac7b19210d375f1d76ddd5f022",
-      ),
-      nat_land: h(
-        "dd73c5c1552ff6ad35537b83f46c9e8c4c2c979eda612fe169e29f3028c63db9",
-      ),
-      nat_lor: h(
-        "8390650998cbee5ee2432a797635d7a331f623eb6fae9f26f17191fcdb880c60",
-      ),
-      nat_xor: h(
-        "04ffebfee34f36c46f63ef6aa347b0b81db8c1cbf3fb9a282799cac024310e69",
-      ),
-      nat_shift_left: h(
-        "89705cc0aca476aa6f161f91006980a425536757e2b7ea949d3aec0edcc3df76",
-      ),
-      nat_shift_right: h(
-        "930ab9e4c2854a0af16c84f89a5aee8e297b65411c499ffae0cf9b27d4ee4b8e",
-      ),
-      bool_type: h(
-        "95fc5d28972d1472a12ddfc2f4a5eefec9a81652fcb63ef06c7f6f6d21a951ab",
-      ),
-      bool_true: h(
-        "fc3a88e4dc16055bc8b797f9544909043015a3a349f2b3fc3e86990b2b9f2999",
-      ),
-      bool_false: h(
-        "c595b2c899f6f0ef39cfab3ac2fbe3b826a7ed21318defc64bbb861d754f8bdf",
-      ),
-      string: h(
-        "3589e6266ed0703fb4008f1e134775dff6bc9a15619687e75222f44253ab8663",
-      ),
-      string_mk: h(
-        "22d668557ab1f800aaf7312f10d9f36ec4d24d0389ac8d0b6d66fd2daf0be903",
-      ),
-      char_type: h(
-        "16e10c6b75431ae16fc23ef43f07512a1f34cff2a33d85b44aae5898e002ac8d",
-      ),
-      char_mk: h(
-        "feb0d0ed724893b5d3d57bafee59ff3cfbe76f43e03fad2b2cf237198aca4457",
-      ),
-      char_of_nat: h(
-        "3ac41b61c538227409f133982435bc97d59489b9129a61d1c4baa14fdb1d6a6a",
-      ),
-      string_of_list: h(
-        "0422aae71a49fd82c87cc8493725a927c1205a9418dc648947d7fde8ed240625",
-      ),
-      string_to_byte_array: h(
-        "714e5b7ea77110a862699b662ecc0bc5a6d70e25bbf6b69dc0f0ec5feb2cfbb3",
-      ),
-      byte_array_empty: h(
-        "5e80d9c092e5fd25417a3a011632e0d060adf9cfd4c0a0bd6798868f067a7cb2",
-      ),
-      list: h(
-        "5886afc36363b59242671f7171bedb319d2a8fa514bc4dc322e3ebcadc85e8ad",
-      ),
-      list_nil: h(
-        "c912ac74d13fa61091059bdae32484e44aea05f439cbbfff7998ef0bfb0e3409",
-      ),
-      list_cons: h(
-        "40b5c0b66834f312bbe3afcadd07911be4182695313be33394eef53d0026e988",
-      ),
-      eq: h("bc3de4d3492ebcf56e98f63459ea705005c1a4216cfc57113617738ae4d84870"),
-      eq_refl: h(
-        "3b01e364067d2ce2ac308da57512992635212487359b62a3c75f60686febef26",
-      ),
-      quot_type: h(
-        "7f7b22596ffee865e1be503216e360ab7dcbd0de645987916484c264ce52f9fe",
-      ),
-      quot_ctor: h(
-        "f06cc3564d1d269e96a51a3f41f1fae1214884ab6d555a11213b8bb2e9e517ef",
-      ),
-      quot_lift: h(
-        "ce268528ab8fe6ec17039a37e73079e3453eae1675c6c76ef302ac87e9a0bd90",
-      ),
-      quot_ind: h(
-        "4ce41a11c66a351352ab27fdfbda9d980f6e296a2fa7f20fdd41377482ed3d52",
-      ),
-      reduce_bool: h(
-        "43875997e42a7c9ea04f24b924da2299aa68e4f2dfb626d67fccfcf5b5132660",
-      ),
-      reduce_nat: h(
-        "604dc8af16829c747638e4b6d58be2baf5280077f8de9db71acb6ef8bbc5f25d",
-      ),
-      // Synthetic kernel-only marker for the original Lean-addressed env.
-      eager_reduce: h(
-        "ff00000000000000000000000000000000000000000000000000000000000013",
-      ),
-      system_platform_num_bits: h(
-        "6fb004fbafb4b68446a57550e21ac08d7599cb157ab194c52fcd7ba1671f10da",
-      ),
-      system_platform_get_num_bits: h(
-        "b9fe4dfbc707ca46de307491541e35ad89a93115245bca3860b74ebcc96a1af2",
-      ),
-      subtype_val: h(
-        "1cf910601d9d86d741333d9547d69d0e299bfe2f99a23a9e838d207fd641eac0",
-      ),
-      nat_dec_le: h(
-        "e34083eb212a258b36374129f6170a9972adceb78356b6c83aa32284ad4edee3",
-      ),
-      nat_dec_eq: h(
-        "a466eec5433bc056803f38b897d9913f91d836260c6ba4176374d1b66f98acc8",
-      ),
-      nat_dec_lt: h(
-        "759a284b4f73e6aa405b409d741fa2b35642693bd041e74b790623121c5e1e33",
-      ),
-      decidable_rec: h(
-        "19e688c7cc2966eb4f79a58eb501c776689f515a7a4cb39fdf7482f1294a1511",
-      ),
-      decidable_is_true: h(
-        "d235a7033c457dfed0f1e34d1d50e97279893b63bdcab3c4490dd9da7d47327f",
-      ),
-      decidable_is_false: h(
-        "2c26576bf92a0d9c2d169be19317e587eec54945a5a241c30dd84908d534d5a1",
-      ),
-      nat_le_of_ble_eq_true: h(
-        "16c9cae0ac27b93644943a84c426db889766476ddb12b0a8b82f76cd2d848561",
-      ),
-      nat_not_le_of_not_ble_eq_true: h(
-        "adb3eaf42d5f4c368bb929b20cec07fa96f9c9fe70d372ec72b25e6510ae14d4",
-      ),
-      nat_eq_of_beq_eq_true: h(
-        "2a2e813ddd907721551718bdb3a2f8248231a041a39563d6d68798aa48425ec8",
-      ),
-      nat_ne_of_beq_eq_false: h(
-        "a09735868d12586f23121cecf12ea2dd1f197f1d44dadc94b7e056d6cceb1980",
-      ),
-      fin: h(
-        "aca8ccd74023a139175db5f1b5b4d037ba1559e25a5d091f2bdc797b23dbb275",
-      ),
-      bool_no_confusion: h(
-        "68bd3c3b59b4bf7285096a8a0b90308db6307b082d24a08b91924b5e6cdcb53a",
-      ),
-      // Int primitives — LEON content-hashes from
-      // `lake test -- rust-kernel-build-prim-origs`. These are the
-      // addresses KIds live at in `orig_kenv`.
-      int: h(
-        "2c073df1601a9c8c7f26bdc51f22b8b7c6072fe6acbea71f244b4f67ceb1472b",
-      ),
-      int_of_nat: h(
-        "c7804dff4a217f857cb6ff58e60d9cb405bc48caffba3240e3f5601d359f9f21",
-      ),
-      int_neg_succ: h(
-        "a8fa07b6cbfec95b534e33a342ef8812aeecd00fbbd2378d71be0d45b876331a",
-      ),
-      int_add: h(
-        "5ef343c73bd4a1c1c7de0701ee822797783a988f8c71965316c7f44a64d5a9c1",
-      ),
-      int_sub: h(
-        "fbfbdc2f6d22d80e3ffb43897dfffedaf5729d5923d412c9bf5cd63ee7790bde",
-      ),
-      int_mul: h(
-        "43b5d0d51e29a259302707a64508345354061bbf2249aba25bd9962d0cdd538e",
-      ),
-      int_neg: h(
-        "8cf21639a1d062be65fa2a475a9a9945d43aa07344dac30a3eacdc512bab14de",
-      ),
-      int_emod: h(
-        "f528f52cf0c85aa71a26f9ed88d11e488c110a7b0854c74ddd0c95ff8f8d1f72",
-      ),
-      int_ediv: h(
-        "8b7ec664a8781cb34ec3678d2ce7fe4e22574ab5605c4988d841c84d8c63d6b0",
-      ),
-      int_bmod: h(
-        "61b9e1d73ecf8dff84ed4e7499c7552211695c9cdfe4a432f17e36c432efc7b2",
-      ),
-      int_bdiv: h(
-        "db0b8bb87b0d4d9fd68fa5039c3657866e122f2dea5e891bd2a0eb16569596b7",
-      ),
-      int_nat_abs: h(
-        "cc43f34a58ce42dfedfdfb0c07a5f31dffa6ba3fb272f3c573ec547eaef722d6",
-      ),
-      int_pow: h(
-        "ae92f05449a4d67697f3649225f88703a6a928a815b7cf6448e92b3a787a1103",
-      ),
-      int_dec_eq: h(
-        "6dc280a4f5be950140e02d61f81ce01b1e21ec06f338a973039bcebf13e8e08b",
-      ),
-      int_dec_le: h(
-        "dcce6645b4b207f4805c7c6878b7704ebd840903387f7848a3e544fe196f6ee3",
-      ),
-      int_dec_lt: h(
-        "ecffd44f689ee7dd7462e3a4b4620ae72637bc59c38b91e8dd5c3d98d899623d",
-      ),
-      punit: h(
-        "e4d0247a1393397d7efa718dc31229b3592a522531595290683ca63dfe420e4d",
-      ),
-      pprod: h(
-        "ce996300ab608fc33ff251a16ac724b19f169dac8ba3fa1c5be2276158adcf5c",
-      ),
-      pprod_mk: h(
-        "0a9e6c68e0531826a4b7e6cb74c5dacb7689e7ef1b78fc21f56acaf65ea25add",
-      ),
-      // Names previously matched via `is_const_named` in whnf.rs.
-      // LEON content-hashes from `lake test -- rust-kernel-build-prim-origs`.
-      nat_rec: h(
-        "02af71bf807e615ee42b36d8d5b210329cddfd1e739fc11f6ba097a2bf74fe5a",
-      ),
-      nat_cases_on: h(
-        "df2e7a477bd8b2ac4936f22c6a60a98e9055759cbcb856895497ee02bbd4af67",
-      ),
-      bit_vec: h(
-        "6f450298341dec31bbbd159414a9193b437e8541e24304c9b680a7d5384643b3",
-      ),
-      bit_vec_to_nat: h(
-        "ae3d3b7ad4c1376fe9d30b335ee19a6e5397672a5b5800f2a0276f8d249d2ed9",
-      ),
-      bit_vec_of_nat: h(
-        "b685da004503283d7a3b2b73a3ad29100762de6eced0b305aede886af05cb3ee",
-      ),
-      bit_vec_ult: h(
-        "7d0fd8eb0e739c1643319a0e6554ee7070aa575416d54c80f8f3d2b166cb7ac8",
-      ),
-      decidable_decide: h(
-        "741a3a166dabcf41a357ad70893ac52feb84068a4bc9de54596bbe602648e3d0",
-      ),
-      lt_lt: h(
-        "3f3eff2353822391e4db7f2b403cb79d2fca36c5a9a0d2dc4fce20850bb8b355",
-      ),
-      of_nat_of_nat: h(
-        "f75083bb57a4a1c5ce0b83945e39da01e11fb9f28f2ab4b57d8f0615ccda8c9d",
-      ),
-      unit: h(
-        "a9be73125f8d296246aa55a183e74d49c420b79c852c36df4fbb87a2ca1d751b",
-      ),
-      punit_size_of_1: h(
-        "6f48fa355d342f1b035ef0777c1ad72e669978816c2c09a3048c4848de4ff443",
-      ),
-      size_of_size_of: h(
-        "ac6c0f1adb8f8f74235dab15b624902bdc0832ed77fae0d62242d0e7717cb06a",
-      ),
-      string_back: h(
-        "54317bf07a28017fbfccf7d9f11c97846c106be220ab98ce1e1b58a196c12be8",
-      ),
-      string_legacy_back: h(
-        "2943dd3d52e8db4fc5b68543ec64d786ba8c70c1f304fe1c0164cc80f2aaaf17",
-      ),
-      string_utf8_byte_size: h(
-        "06ba07154a1cd0e1e9eec2b6e27b195a6fc3ae20a70d1ced7643a61e4e3e6d0f",
-      ),
-      string_append: h(
-        "93faafad0b7eff95765986eb5f5cb10635818129b72d8e7fdddaca2a5fb45844",
-      ),
-      string_dec_eq: h(
-        "a53c141a7bbbbdf77d4a2cb049911fd4001f7d71b94ed5c3b877e837da94c349",
-      ),
-    }
-  }
-}
+/// `PrimAddrs` and `reserved_marker_name` live in `ix-common` so crates
+/// below the kernel (notably witness builders, which must seed the
+/// primitives the kernel fabricates during reduction) can reach them
+/// without depending on `ix-kernel` — that edge would be a cycle, since
+/// `ix-kernel` depends on `ixon`. Re-exported here because this is where
+/// kernel code has always named them.
+pub use ix_common::prim_addrs::{PrimAddrs, reserved_marker_name};
 
 impl<M: KernelMode> Primitives<M> {
   /// Resolve primitives from the environment using the canonical
@@ -1171,14 +338,6 @@ impl<M: KernelMode> Primitives<M> {
   }
 }
 
-pub fn reserved_marker_name(addr: &Address) -> Option<&'static str> {
-  static MARKERS: LazyLock<[(&'static str, Address); 2]> =
-    LazyLock::new(PrimAddrs::reserved_marker_addrs);
-  MARKERS
-    .iter()
-    .find_map(|(name, marker_addr)| (marker_addr == addr).then_some(*name))
-}
-
 #[cfg(test)]
 mod tests {
   use std::collections::HashMap;